Merge branch '2.0' into 2.1

tests/compute/docker/test_docker.py

@@ -19,17 +19,17 @@ import pytest
 import asyncio
 from unittest.mock import MagicMock
 
-from tests.utils import asyncio_patch
+from tests.utils import asyncio_patch, AsyncioMagicMock
 from gns3server.compute.docker import Docker
-from gns3server.compute.docker.docker_error import DockerError
+from gns3server.compute.docker.docker_error import DockerError, DockerHttp404Error
 
 
 @pytest.fixture
 def vm():
     vm = Docker()
     vm._connected = True
-    vm._connector = MagicMock()
-    vm._connector.closed = False
+    vm._session = MagicMock()
+    vm._session.closed = False
     return vm
 
 
@@ -44,14 +44,14 @@ def test_query_success(loop, vm):
         return b'{"c": false}'
 
     response.read.side_effect = read
-    with asyncio_patch("aiohttp.request", return_value=response) as mock:
-        data = loop.run_until_complete(asyncio.async(vm.query("POST", "test", data={"a": True}, params={"b": 1})))
-    mock.assert_called_with('POST',
-                            'http://docker/test',
-                            connector=vm._connector,
-                            data='{"a": true}',
-                            headers={'content-type': 'application/json'},
-                            params={'b': 1})
+    vm._session.request = AsyncioMagicMock(return_value=response)
+    data = loop.run_until_complete(asyncio.async(vm.query("POST", "test", data={"a": True}, params={"b": 1})))
+    vm._session.request.assert_called_with('POST',
+                                           'http://docker/test',
+                                           data='{"a": true}',
+                                           headers={'content-type': 'application/json'},
+                                           params={'b': 1},
+                                           timeout=300)
 
     assert data == {"c": False}
 
@@ -66,15 +66,15 @@ def test_query_error(loop, vm):
         return b"NOT FOUND"
 
     response.read.side_effect = read
-    with asyncio_patch("aiohttp.request", return_value=response) as mock:
-        with pytest.raises(DockerError):
-            data = loop.run_until_complete(asyncio.async(vm.query("POST", "test", data={"a": True}, params={"b": 1})))
-    mock.assert_called_with('POST',
-                            'http://docker/test',
-                            connector=vm._connector,
-                            data='{"a": true}',
-                            headers={'content-type': 'application/json'},
-                            params={'b': 1})
+    vm._session.request = AsyncioMagicMock(return_value=response)
+    with pytest.raises(DockerError):
+        data = loop.run_until_complete(asyncio.async(vm.query("POST", "test", data={"a": True}, params={"b": 1})))
+    vm._session.request.assert_called_with('POST',
+                                           'http://docker/test',
+                                           data='{"a": true}',
+                                           headers={'content-type': 'application/json'},
+                                           params={'b': 1},
+                                           timeout=300)
 
 
 def test_query_error_json(loop, vm):
@@ -87,15 +87,15 @@ def test_query_error_json(loop, vm):
         return b'{"message": "Error"}'
 
     response.read.side_effect = read
-    with asyncio_patch("aiohttp.request", return_value=response) as mock:
-        with pytest.raises(DockerError):
-            data = loop.run_until_complete(asyncio.async(vm.query("POST", "test", data={"a": True}, params={"b": 1})))
-    mock.assert_called_with('POST',
-                            'http://docker/test',
-                            connector=vm._connector,
-                            data='{"a": true}',
-                            headers={'content-type': 'application/json'},
-                            params={'b': 1})
+    vm._session.request = AsyncioMagicMock(return_value=response)
+    with pytest.raises(DockerError):
+        data = loop.run_until_complete(asyncio.async(vm.query("POST", "test", data={"a": True}, params={"b": 1})))
+    vm._session.request.assert_called_with('POST',
+                                           'http://docker/test',
+                                           data='{"a": true}',
+                                           headers={'content-type': 'application/json'},
+                                           params={'b': 1},
+                                           timeout=300)
 
 
 def test_list_images(loop):
@@ -134,3 +134,31 @@ def test_list_images(loop):
     assert {"image": "ubuntu:latest"} in images
     assert {"image": "ubuntu:12.10"} in images
     assert {"image": "ubuntu:quantal"} in images
+
+
+def test_pull_image(loop):
+    class Response:
+        """
+        Simulate a response splitted in multiple packets
+        """
+
+        def __init__(self):
+            self._read = -1
+
+        @asyncio.coroutine
+        def read(self, size):
+            self._read += 1
+            if self._read == 0:
+                return b'{"progress": "0/100",'
+            elif self._read == 1:
+                return '"id": 42}'
+            else:
+                None
+
+    mock_query = MagicMock()
+    mock_query.content.return_value = Response()
+
+    with asyncio_patch("gns3server.compute.docker.Docker.query", side_effect=DockerHttp404Error("404")):
+        with asyncio_patch("gns3server.compute.docker.Docker.http_query", return_value=mock_query) as mock:
+            images = loop.run_until_complete(asyncio.async(Docker.instance().pull_image("ubuntu")))
+            mock.assert_called_with("POST", "images/create", params={"fromImage": "ubuntu"}, timeout=None)

tests/compute/docker/test_docker_vm.py

@@ -795,33 +795,6 @@ def test_adapter_remove_nio_binding_invalid_adapter(vm, loop):
         loop.run_until_complete(asyncio.async(vm.adapter_remove_nio_binding(12)))
 
 
-def test_pull_image(loop, vm):
-    class Response:
-        """
-        Simulate a response splitted in multiple packets
-        """
-
-        def __init__(self):
-            self._read = -1
-
-        @asyncio.coroutine
-        def read(self, size):
-            self._read += 1
-            if self._read == 0:
-                return b'{"progress": "0/100",'
-            elif self._read == 1:
-                return '"id": 42}'
-            else:
-                None
-
-    mock_query = MagicMock()
-    mock_query.content.return_value = Response()
-
-    with asyncio_patch("gns3server.compute.docker.Docker.http_query", return_value=mock_query) as mock:
-        images = loop.run_until_complete(asyncio.async(vm.pull_image("ubuntu")))
-        mock.assert_called_with("POST", "images/create", params={"fromImage": "ubuntu"})
-
-
 def test_start_capture(vm, tmpdir, manager, free_console_port, loop):
 
     output_file = str(tmpdir / "test.pcap")

tests/controller/test_controller.py

@@ -192,7 +192,8 @@ def test_import_remote_gns3vm_1_x(controller, controller_config_path, async_run)
 def test_settings(controller):
     controller._notification = MagicMock()
     controller.settings = {"a": 1}
-    controller._notification.emit.assert_called_with("settings.updated", {"a": 1})
+    controller._notification.emit.assert_called_with("settings.updated", controller.settings)
+    assert controller.settings["modification_uuid"] is not None
 
 
 def test_load_projects(controller, projects_dir, async_run):

tests/handlers/api/controller/test_settings.py

@@ -29,4 +29,5 @@ def test_settings(http_controller):
     assert response.status == 201
     response = http_controller.get('/settings', example=True)
     assert response.status == 200
-    assert response.json == query
+    assert response.json["test"] is True
+    assert response.json["modification_uuid"] is not None