Python project.Project類代碼示例

def test_image_in_project(tmpdir):
    project_dir = tmpdir / "project" / "project-files"
    os.makedirs(str(project_dir / "images"))

    project = Project()
    project.setFilesDir(str(tmpdir / "project"))

    topology = Topology()
    topology.project = project

    with open(str(project_dir / "images" / "1.jpg"), "w+") as f:
        f.write("AA")

    image1 = PixmapImageItem(None, "images/1.jpg")
    topology.addImage(image1)
    assert image1 in topology._images

    image2 = PixmapImageItem(None, "images/1.jpg")
    topology.addImage(image2)
    assert image1 in topology._images
    assert image2 in topology._images

    topology.removeImage(image2)
    assert os.path.exists(str(project_dir / "images" / "1.jpg"))

    # If not image use this file delete it
    topology.removeImage(image1)
    assert not os.path.exists(str(project_dir / "images" / "1.jpg"))

def test_project_post_non_created_project_remote_server_two_query_two_server(remote_server, local_server):
    """
    Test a post on a remote servers. The project
    is not created on the server and should be created automaticaly.
    And after make the call

    Another server is also waiting for the project to be create on the first server
    """

    uuid = str(uuid4())
    project = Project()
    project._created_servers = set()
    project.setId(uuid)

    with patch("gns3.http_client.HTTPClient.createHTTPQuery") as mock:
        project.post(remote_server, "/test", lambda: 0, body={"test": "test"})
        args, kwargs = mock.call_args

        # Send a query from another server, this should wait the first server to finish
        project.post(local_server, "/test3", lambda: 0, body={"test": "test"})

        assert args[0] == "POST"
        assert args[1] == "/projects"
        assert kwargs["body"] == {"name": "untitled", "temporary": False, "project_id": uuid}
        project.post(remote_server, "/test2", lambda: 0, body={"test": "test"})

        assert mock.call_count == 1
        args[2]({}, server=remote_server)

        assert len(project._created_servers) == 1

        calls = mock.mock_calls

        name, args, kwargs = calls[1]
        assert args[0] == "GET"
        assert args[1] == "/projects/{uuid}/notifications".format(uuid=uuid)

        name, args, kwargs = calls[3]
        assert args[0] == "POST"
        assert args[1] == "/projects/{uuid}/test".format(uuid=uuid)
        assert kwargs["body"] == {"test": "test"}

        # Call to the create project on second server
        name, args, kwargs = calls[4]
        assert args[0] == "POST"
        assert args[1] == "/projects".format(uuid=uuid)
        assert kwargs["body"] == {"name": "untitled", "project_id": uuid, "path": None, "temporary": False}

        name, args, kwargs = calls[5]
        assert args[0] == "POST"
        assert args[1] == "/projects/{uuid}/test2".format(uuid=uuid)
        assert kwargs["body"] == {"test": "test"}

def test_project_moveFromTemporaryToPath(tmpdir, local_server):

    project = Project()
    project.setId(str(uuid4()))
    project._created_servers = set((local_server, ))
    project._temporary = True

    with patch("gns3.http_client.HTTPClient.put") as mock:
        project.moveFromTemporaryToPath(str(tmpdir))

        assert mock.called
        args, kwargs = mock.call_args
        assert args[0] == "/projects/{project_id}".format(project_id=project.id())
        assert kwargs["body"] == {"name": "untitled", "path": str(tmpdir), "temporary": False}

    assert project.temporary() is False
    assert project.filesDir() == str(tmpdir)

def test_project_post_non_created_project_local_server(tmpdir, local_server):
    """
    Test a post on a local servers. The project
    is not created on the server and should be created automaticaly.
    And after make the call
    """

    uuid = str(uuid4())
    project = Project()
    project.setId(uuid)
    project.setFilesDir(str(tmpdir))

    with patch("gns3.http_client.HTTPClient.createHTTPQuery") as mock:
        project.post(local_server, "/test", lambda: 0, body={"test": "test"})

        args, kwargs = mock.call_args
        assert args[0] == "POST"
        assert args[1] == "/projects"
        assert kwargs["body"] == {"name": "untitled",
                                  "temporary": False,
                                  "project_id": uuid,
                                  "path": str(tmpdir)}

        args[2]({}, server=local_server)

        assert len(project._created_servers) == 1

        args, kwargs = mock.call_args
        assert args[0] == "POST"
        assert args[1] == "/projects/{uuid}/test".format(uuid=uuid)
        assert kwargs["body"] == {"test": "test"}

def test_project_create(tmpdir, controller):
    """
    Test a post on a local servers. The project
    is not created on the server and should be created automatically.
    And after make the call
    """

    uuid = str(uuid4())
    project = Project()
    project.setFilesDir(str(tmpdir))
    project.setName("test")

    project.create()

    mock = controller._http_client.createHTTPQuery
    assert mock.called
    args, kwargs = mock.call_args
    assert args[0] == "POST"
    assert args[1] == "/projects"
    assert kwargs["body"] == {"name": "test",
                              "path": str(tmpdir),
                              "grid_size": 75,
                              "drawing_grid_size": 25,
                              "show_grid": False,
                              "snap_to_grid": False,
                              "show_interface_labels": False}

    args[2]({"project_id": uuid, "name": "test"})

    assert project._closed is False

def test_project_close_error(local_server):

    uuid = uuid4()
    mock = MagicMock
    with patch("gns3.http_client.HTTPClient.post") as mock:

        signal = MagicMock()

        project = Project()
        project.setId(uuid)
        project._created_servers = set((local_server, ))

        mock_signal = MagicMock()
        mock_signal_closed = MagicMock()
        project.project_about_to_close_signal.connect(mock_signal)
        project.project_closed_signal.connect(mock_signal_closed)

        project.close()

        assert mock_signal.called
        assert not mock_signal_closed.called

        args, kwargs = mock.call_args

        assert args[0] == "/projects/{project_id}/close".format(project_id=uuid)
        assert kwargs["body"] == {}

        # Call the project close callback
        args[1]({"message": "Can't connect"}, error=True, server=local_server)
        assert mock_signal_closed.called

        assert project.closed()

def project(local_server):

    from gns3.project import Project

    project = Project()
    project.setId(str(uuid.uuid4()))
    project._created_servers.add(local_server)
    project.setType("local")
    project.setName("unsaved")
    return project

def test_project_update(controller):
    project = Project()
    project.setVariables([{'name': 'TEST'}])
    project.setSupplier({'logo': 'test.png', 'url':  'http://domain'})
    project.update()
    mock = controller._http_client.createHTTPQuery
    args, kwargs = mock.call_args
    body = kwargs['body']
    assert body['variables'] == [{'name': 'TEST'}]
    assert body['supplier'] == {'logo': 'test.png', 'url':  'http://domain'}

def test_project_parse_response():
    result = {
        'project_id': 'projectid',
        'name': 'projectname',
        'filename': 'filename.gns3',
        'variables': [{'name': 'TEST'}],
        'supplier': {'logo': 'test.png', 'url':  'http://domain'}
    }
    project = Project()
    project._parseResponse(result)
    assert project.id() == 'projectid'
    assert project.name() == 'projectname'
    assert project.filename() == 'filename.gns3'
    assert project.variables() == [{'name': 'TEST'}]
    assert project.supplier() == {'logo': 'test.png', 'url':  'http://domain'}

def project():

    from gns3.project import Project

    project = Project()
    project.setId(str(uuid.uuid4()))
    project._created = True
    project.setName("unsaved")
    return project

def test_project_commit(local_server):

    with patch("gns3.http_client.HTTPClient.post") as mock:

        project = Project()
        project.setId(str(uuid4()))
        project._created_servers = set((local_server, ))
        project.commit()

        assert mock.called
        args, kwargs = mock.call_args

        assert args[0] == "/projects/{project_id}/commit".format(project_id=project.id())

def test_image_outside_project(tmpdir):
    """
    By security we do not delete image outside project.
    This should not append but if someone reuse the image items for
    something else.
    """

    project_img_dir = tmpdir / "project" / "project-files" / "images"
    os.makedirs(str(project_img_dir))

    project = Project()
    project.setFilesDir(str(tmpdir / "project"))

    topology = Topology()
    topology.project = project

    with open(str(tmpdir / "1.jpg"), "w+") as f:
        f.write("AA")

    image1 = PixmapImageItem(None, str(tmpdir / "1.jpg"))
    topology.addImage(image1)
    assert image1 in topology._images
    topology.removeImage(image1)
    assert os.path.exists(str(tmpdir / "1.jpg"))

def project(local_server):

    from gns3.project import Project

    project = Project()
    project.setId(str(uuid.uuid4()))
    project._listen_notification = True
    project._created_servers.add(local_server)
    project.setName("unsaved")
    return project

def test_project_destroy(controller):
    project = Project()
    project.setId(str(uuid4()))
    project.destroy()

    mock = controller._http_client.createHTTPQuery
    assert mock.called
    args, kwargs = mock.call_args

    assert args[0] == "DELETE"
    assert args[1] == "/projects/{project_id}".format(project_id=project.id())

def test_project_post_non_created_project_remote_server_two_query(remote_server):
    """
    Test a post on a remote servers. The project
    is not created on the server and should be created automaticaly.
    And after make the call
    """

    uuid = str(uuid4())
    project = Project()
    project._created_servers = set()
    project.setId(uuid)

    with patch("gns3.http_client.HTTPClient.createHTTPQuery") as mock:
        project.post(remote_server, "/test", lambda: 0, body={"test": "test"})
        args, kwargs = mock.call_args

        assert args[0] == "POST"
        assert args[1] == "/projects"
        assert kwargs["body"] == {"name": "untitled", "temporary": False, "project_id": uuid}
        project.post(remote_server, "/test2", lambda: 0, body={"test": "test"})

        assert mock.call_count == 1
        args[2]({}, server=remote_server)

        assert len(project._created_servers) == 1

        calls = mock.mock_calls

        name, args, kwargs = calls[1]
        assert args[1] == "/projects/{uuid}/notifications".format(uuid=uuid)
        assert args[0] == "GET"

        name, args, kwargs = calls[3]
        assert args[1] == "/projects/{uuid}/test".format(uuid=uuid)
        assert args[0] == "POST"
        assert kwargs["body"] == {"test": "test"}

        name, args, kwargs = calls[4]
        assert args[0] == "POST"
        assert args[1] == "/projects/{uuid}/test2".format(uuid=uuid)
        assert kwargs["body"] == {"test": "test"}