def test_send_requests_success(self):
        with mock.patch(
                'util.UpnpPunch._send_soap_request') as mock_send_request:
            mock_send_request.return_value = mock.MagicMock(status=200)
            upnp._send_requests(['msg'], None, None, None)

        assert mock_send_request.called

    def openport(self, port=None, check=True):
        if not port:
            port = self.port
        if self.port_opened:
            return True  # Port already opened
        if check:  # Check first if its already opened
            time.sleep(1)  # Wait for port open
            if self.testOpenport(port, use_alternative=False)["result"] is True:
                return True  # Port already opened

        if config.tor == "always":  # Port opening won't work in Tor mode
            return False

        self.log.info("Trying to open port using UpnpPunch...")
        try:
            UpnpPunch.ask_to_open_port(self.port, 'ZeroNet', retries=3, protos=["TCP"])
        except (UpnpPunch.UpnpError, UpnpPunch.IGDError, socket.error) as err:
            self.log.error("UpnpPunch run error: %s" %
                           Debug.formatException(err))
            return False

        if self.testOpenport(port)["result"] is True:
            self.upnp_port_opened = True
            return True

        self.log.info("Upnp mapping failed :( Please forward port %s on your router to your ipaddress" % port)
        return False

    def test_perform_m_search_socket_error(self, mock_socket):
        mock_socket.recv.side_effect = socket.error('Timeout error')

        with mock.patch('util.UpnpPunch.socket.socket',
                        return_value=mock_socket):
            with pytest.raises(upnp.UpnpError):
                upnp.perform_m_search('127.0.0.1')

    def test_send_requests_failed(self):
        with mock.patch(
                'util.UpnpPunch._send_soap_request') as mock_send_request:
            mock_send_request.return_value = mock.MagicMock(status=500)
            with pytest.raises(upnp.UpnpError):
                upnp._send_requests(['msg'], None, None, None)

        assert mock_send_request.called

 def stop(self):
     if self.running and self.upnp_port_opened:
         self.log.debug('Closing port %d' % self.port)
         try:
             UpnpPunch.ask_to_close_port(self.port, protos=["TCP"])
             self.log.info('Closed port via upnp.')
         except (UpnpPunch.UpnpError, UpnpPunch.IGDError), err:
             self.log.info("Failed at attempt to use upnp to close port: %s" % err)

    def test_perform_m_search(self, mock_socket):
        local_ip = '127.0.0.1'

        with mock.patch('util.UpnpPunch.socket.socket',
                        return_value=mock_socket):
            result = upnp.perform_m_search(local_ip)
            assert result == 'Hello'
            assert local_ip == mock_socket.bind.call_args_list[0][0][0][0]
            assert ('239.255.255.250',
                    1900) == mock_socket.sendto.call_args_list[0][0][1]

	def openport(self, port=None, check=True):
		if not port: port = self.port
		if self.port_opened: return True # Port already opened
		if check: # Check first if its already opened
			if self.testOpenport(port)["result"] == True:
				return True # Port already opened

		self.log.info("Trying to open port using UpnpPunch...")
		try:
			upnp_punch = UpnpPunch.open_port(self.port, 'ZeroNet')
			upnp_punch = True
		except Exception, err:
			self.log.error("UpnpPunch run error: %s" % Debug.formatException(err))
			upnp_punch = False

    def openport(self, port=None, check=True):
        if not port:
            port = self.port
        if self.port_opened:
            return True  # Port already opened
        if check:  # Check first if its already opened
            time.sleep(1)  # Wait for port open
            if self.testOpenport(port, use_alternative=False)["result"] is True:
                return True  # Port already opened

        if config.tor == "always":  # Port opening won't work in Tor mode
            return False

        self.log.info("Trying to open port using UpnpPunch...")
        try:
            upnp_punch = UpnpPunch.open_port(self.port, 'Phantom')
            upnp_punch = True
        except Exception, err:
            upnp_punch = False

 def getMyIps(self):
     return UpnpPunch._get_local_ips()

 def test_create_close_message_parsable(self):
     from xml.parsers.expat import ExpatError
     msg, _ = upnp._create_close_message('127.0.0.1', 8888)
     try:
         upnp.parseString(msg)
     except ExpatError as e:
         pytest.fail('Incorrect XML message: {}'.format(e))

 def test_communicate_with_igd_succeed_despite_single_failure(
         self, mock_orchestrate, mock_get_local_ips):
     mock_get_local_ips.return_value = ['192.168.0.12']
     mock_orchestrate.side_effect = [upnp.UpnpError, None]
     upnp._communicate_with_igd(retries=2)
     assert mock_get_local_ips.called
     assert mock_orchestrate.called

    def test_ask_to_open_port_failure(self, mock_send_requests,
                                      mock_collect_idg, mock_local_ips):
        mock_local_ips.return_value = ['192.168.0.12']
        mock_collect_idg.return_value = {'upnp_schema': 'schema-yo'}
        mock_send_requests.side_effect = upnp.UpnpError()

        with pytest.raises(upnp.UpnpError):
            upnp.ask_to_open_port()

 def test_communicate_with_igd_total_failure(self, mock_orchestrate,
                                             mock_get_local_ips):
     mock_get_local_ips.return_value = ['192.168.0.12']
     mock_orchestrate.side_effect = [upnp.UpnpError, upnp.IGDError]
     with pytest.raises(upnp.UpnpError):
         upnp._communicate_with_igd(retries=2)
     assert mock_get_local_ips.called
     assert mock_orchestrate.called

 def test_parse_for_errors_error(self, httplib_response):
     soap_error = ('<document>'
                   '<errorCode>500</errorCode>'
                   '<errorDescription>Bad request</errorDescription>'
                   '</document>')
     rsp = httplib_response(status=500, body=soap_error)
     with pytest.raises(upnp.IGDError) as exc:
         upnp._parse_for_errors(rsp)
     assert 'SOAP request error' in exc.value.message

    def test_orchestrate_soap_request_without_desc(self, mock_send_requests,
                                                   mock_collect_idg):
        soap_mock = mock.MagicMock()
        args = ['127.0.0.1', 31337, soap_mock, {'upnp_schema': 'schema-yo'}]
        mock_collect_idg.return_value = args[-1]

        upnp._orchestrate_soap_request(*args[:-1])

        assert mock_collect_idg.called
        soap_mock.assert_called_with(*args[:2] + [None, 'UDP', 'schema-yo'])
        assert mock_send_requests.called

 def test_retrieve_location_from_ssdp(self, url_obj):
     ctrl_location = url_obj.geturl()
     parsed_location = urlparse(ctrl_location)
     rsp = ('auth: gibberish\r\nlocation: {0}\r\n'
            'Content-Type: text/html\r\n\r\n').format(ctrl_location)
     result = upnp._retrieve_location_from_ssdp(rsp)
     assert result == parsed_location

 def test_create_close_message_contains_right_stuff(self):
     settings = {'protocol': 'test proto',
                 'upnp_schema': 'test schema'}
     msg, fn_name = upnp._create_close_message('127.0.0.1', 8888, **
                                               settings)
     assert fn_name == 'DeletePortMapping'
     assert '8888' in msg
     assert settings['protocol'] in msg
     assert settings['upnp_schema'] in msg

 def test_create_open_message_contains_right_stuff(self):
     settings = {'description': 'test desc',
                 'protocol': 'test proto',
                 'upnp_schema': 'test schema'}
     msg, fn_name = upnp._create_open_message('127.0.0.1', 8888, **settings)
     assert fn_name == 'AddPortMapping'
     assert '127.0.0.1' in msg
     assert '8888' in msg
     assert settings['description'] in msg
     assert settings['protocol'] in msg
     assert settings['upnp_schema'] in msg

    def test_ask_to_open_port_success(self, mock_send_requests,
                                      mock_collect_idg, mock_local_ips):
        mock_collect_idg.return_value = {'upnp_schema': 'schema-yo'}
        mock_local_ips.return_value = ['192.168.0.12']

        result = upnp.ask_to_open_port(retries=5)

        soap_msg = mock_send_requests.call_args[0][0][0][0]

        assert result is None

        assert mock_collect_idg.called
        assert '192.168.0.12' in soap_msg
        assert '15441' in soap_msg
        assert 'schema-yo' in soap_msg

 def test_parse_for_errors_bad_rsp(self, httplib_response):
     rsp = httplib_response(status=500)
     with pytest.raises(upnp.IGDError) as exc:
         upnp._parse_for_errors(rsp)
     assert 'Unable to parse' in exc.value.message