def test_local_port(self):
port_config = get_port_config([])
upnpc = MagicMock()
upnpc.port_open_on_router = MagicMock(return_value=False)
mapper = PortMapper(port_config, upnpc)
existing_ports = [2000, 2001, 2003]
self.assertEquals([80, 2002, 2004], mapper.find_available_ports_to_try(existing_ports, 80, 3))
def test_sync_server_side_client_ip(self):
service_config = get_service_config([
Service("ownCloud", "http", "_http._tcp", 80, url="owncloud"),
Service("SSH", "https", "_http._tcp", 81, url=None)
])
port_config = get_port_config([Port(80, 80), Port(81, 81)])
upnpc = get_upnpc(external_ip='10.1.1.1')
upnpc.mapped_external_ports = MagicMock(side_effect=[[], [80]])
port_mapper = get_port_mapper(port_config, upnpc)
domain_config = get_domain_config(Domain('boris', 'some_update_token'))
responses.add(responses.POST,
"http://api.domain.com/domain/update",
status=200,
body="{'message': 'Domain was updated'}",
content_type="application/json")
insider_config = get_insider_config('domain.com', 'http://api.domain.com')
dns = Dns(insider_config, domain_config, service_config, port_mapper, '127.0.0.1')
dns.sync()
expected_request = '''
{
"services": [
{"name": "ownCloud", "protocol": "http", "type": "_http._tcp", "port": 80, "local_port": 80, "url": "owncloud"},
{"name": "SSH", "protocol": "https", "type": "_http._tcp", "port": 81, "local_port": 81, "url": null}
],
"token": "some_update_token",
"local_ip": "127.0.0.1"
}
'''
self.assertSingleRequest(expected_request)
def test_open_port(self):
port_config = get_port_config([])
upnpc = MagicMock()
upnpc.port_open_on_router = MagicMock(side_effect=[True, True, False, False, False])
mapper = PortMapper(port_config, upnpc)
existing_ports = []
self.assertEquals([2001, 2002, 2003], mapper.find_available_ports_to_try(existing_ports, 1999, 3))
def test_first_gap(self):
port_config = get_port_config([])
upnpc = MagicMock()
upnpc.port_open_on_router = MagicMock(return_value=False)
mapper = PortMapper(port_config, upnpc)
existing_ports = [2000, 2001, 2003]
ports_to_try = mapper.find_available_ports_to_try(existing_ports, 2000, 3)
self.assertEquals([2002, 2004, 2005], ports_to_try)
def test_add_or_update(self):
port_config = get_port_config([])
port_config.add_or_update(Port(80, 10000))
port_config.add_or_update(Port(80, 10000))
port_config.add_or_update(Port(81, 10000))
port_config.add_or_update(Port(81, 10000))
self.assertEquals(len(port_config.load()), 2)
def test_sync_adds_port(self):
port_config = get_port_config([Port(80, 10001)])
upnpc = MagicMock()
upnpc.port_open_on_router = MagicMock(return_value=False)
mapper = PortMapper(port_config, upnpc)
mapper.sync()
read = port_config.get(80)
self.assertEquals(80, read.external_port)
self.assertTrue(upnpc.add.called)
def test_get_not_existing_service(self):
service_config = get_service_config([])
port_config = get_port_config([])
upnpc = get_upnpc(external_ip='192.167.44.52')
port_mapper = get_port_mapper(port_config, upnpc)
domain_config = get_domain_config(None)
insider_config = get_insider_config('domain.com', 'http://api.domain.com')
dns = Dns(insider_config, domain_config, service_config, port_mapper, '127.0.0.1')
service = dns.get_service("ownCloud")
self.assertIsNone(service)
def test_sync_new_ports(self):
port_config = get_port_config([])
upnpc = MagicMock()
upnpc.port_open_on_router = MagicMock(return_value=False)
mapper = PortMapper(port_config, upnpc)
mapper.sync_new_port(80)
read = port_config.get(80)
self.assertEquals(80, read.external_port)
upnpc.add.assert_called_with(80, 80)
def test_sync_cleans_duplicate_mappings(self):
port_config = get_port_config([Port(80, 2000)])
upnpc = MagicMock()
upnpc.get_external_ports = MagicMock(return_value=[2000, 2001])
mapper = PortMapper(port_config, upnpc)
mapper.sync()
read = port_config.get(80)
self.assertEquals(2000, read.external_port)
upnpc.remove.assert_called_with(2001)
def test_add_success(self):
port_config = get_port_config([])
upnpc = MagicMock()
upnpc.port_open_on_router = MagicMock(return_value=False)
mapper = PortMapper(port_config, upnpc)
mapping = mapper.add(80)
self.assertIsNotNone(mapping)
self.assertEquals(80, mapping.local_port)
self.assertEquals(80, mapping.external_port)
self.assertTrue(upnpc.add.called)
read = port_config.get(80)
self.assertEquals(80, read.external_port)
def test_add_success_after_first_failed(self):
port_config = get_port_config([])
upnpc = FailingUpnpc(2)
upnpc.port_open_on_router = MagicMock(return_value=False)
upnpc.external_ip = MagicMock()
upnpc.mapped_external_ports = MagicMock()
mapper = PortMapper(port_config, upnpc)
mapping = mapper.add(80)
self.assertIsNotNone(mapping)
self.assertEquals(80, mapping.local_port)
self.assertEquals(2001, mapping.external_port)
read = port_config.get(80)
self.assertEquals(2001, read.external_port)
def test_get_service(self):
service_config = get_service_config([])
port_config = get_port_config([])
upnpc = get_upnpc(external_ip='192.167.44.52')
port_mapper = get_port_mapper(port_config, upnpc)
domain_config = get_domain_config(None)
insider_config = get_insider_config('domain.com', 'http://api.domain.com')
dns = Dns(insider_config, domain_config, service_config, port_mapper, '127.0.0.1')
dns.add_service("ownCloud", "http", "_http._tcp", 80, url="owncloud")
service = dns.get_service("ownCloud")
self.assertIsNotNone(service)
self.assertEquals("ownCloud", service.name)
self.assertEquals("_http._tcp", service.type)
self.assertEquals(80, service.port)
self.assertEquals("owncloud", service.url)
def test_endpoints(self):
service_config = get_service_config([
Service("ownCloud", "http", "_http._tcp", 80, url="owncloud"),
Service("SSH", "https", "_http._tcp", 81, url=None)
])
port_config = get_port_config([Port(80, 8080), Port(81, 8181)])
upnpc = get_upnpc(external_ip='10.1.1.1')
# upnpc.mapped_external_ports = MagicMock(side_effect=[[], [80]])
port_mapper = get_port_mapper(port_config, upnpc)
domain_config = get_domain_config(Domain('boris', 'some_update_token'))
insider_config = get_insider_config('domain.com', 'http://api.domain.com')
dns = Dns(insider_config, domain_config, service_config, port_mapper, '127.0.0.1')
endpoints = dns.endpoints()
assert len(endpoints) == 2
assert endpoints[0].service.name == 'ownCloud'
assert endpoints[0].external_port == 8080
assert endpoints[1].service.name == 'SSH'
assert endpoints[1].external_port == 8181
def test_sync_server_error(self):
service_config = get_service_config([Service("ownCloud", "http", "_http._tcp", 80, url="owncloud")])
port_config = get_port_config([Port(80, 10000)])
upnpc = get_upnpc(external_ip='192.167.44.52')
port_mapper = get_port_mapper(port_config, upnpc)
domain_config = get_domain_config(Domain('boris', 'some_update_token'))
responses.add(responses.POST,
"http://api.domain.com/domain/update",
status=400,
body='{"message": "Unknown update token"}',
content_type="application/json")
insider_config = get_insider_config('domain.com', 'http://api.domain.com')
dns = Dns(insider_config, domain_config, service_config, port_mapper, '127.0.0.1')
with self.assertRaises(Exception) as context:
dns.sync()
self.assertEquals(context.exception.message, "Unknown update token")
def test_add_service(self):
service_config = get_service_config([])
port_config = get_port_config([])
upnpc = get_upnpc(external_ip='192.167.44.52')
port_mapper = get_port_mapper(port_config, upnpc)
domain_config = get_domain_config(None)
insider_config = get_insider_config('domain.com', 'http://api.domain.com')
dns = Dns(insider_config, domain_config, service_config, port_mapper, '127.0.0.1')
dns.add_service("ownCloud", "http", "_http._tcp", 80, url="owncloud")
services = service_config.load()
self.assertEquals(1, len(services))
service = services[0]
self.assertEquals("ownCloud", service.name)
self.assertEquals("_http._tcp", service.type)
self.assertEquals(80, service.port)
self.assertEquals("owncloud", service.url)
mappings = port_config.load()
self.assertEquals(1, len(mappings))
mapping = mappings[0]
self.assertEquals(80, mapping.local_port)
