test_matplotlib_draw - Code Metrics - Inspection of "test: add unit tests for matplotlib draw and plot..." - erivlis/graphinate - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 88ed15...38252d )

by Eran

created 2025-04-15 17:05 UTC

test_matplotlib_draw A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	246
Duplicated Lines	62.2 %

Importance

Changes

Metric	Value
wmc	9
eloc	162
dl	153
loc	246
rs	10
c	0
b	0
f	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	TestDraw.test_draw_no_node_labels_attribute()	27	27	1
A	TestDraw.test_draw_with_default_parameters()	0	23	1
A	TestDraw.test_draw_with_edge_labels_on()	0	23	1
A	TestDraw.test_draw_empty_graph()	0	22	1
A	TestDraw.test_draw_non_planar_graph()	23	23	1
A	TestDraw.test_draw_with_node_labels_off()	24	24	1
A	TestDraw.test_draw_planar_graph()	23	23	1
A	TestDraw.test_draw_with_both_labels_on()	27	27	1
A	TestDraw.test_draw_no_edge_labels_attribute()	29	29	1

How to fix Duplicated Code

import networkx as nx

from graphinate.renderers.matplotlib import draw


class TestDraw:

    # Drawing a graph with default parameters (node labels on, edge labels off)
    def test_draw_with_default_parameters(self, mocker):
        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0, label='Node0')
        graph.add_node(1, label='Node1')
        graph.add_edge(0, 1)

        # Act
        draw(graph)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once_with(graph)
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_nx_draw.assert_called_once()
        mock_nx_draw_edge_labels.assert_not_called()

    # Drawing a graph with node labels turned off
    def test_draw_with_node_labels_off(self, mocker):

        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0, label='Node0')
        graph.add_node(1, label='Node1')
        graph.add_edge(0, 1)

        # Act
        draw(graph, with_node_labels=False)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once_with(graph)
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_nx_draw.assert_called_once()
        # Check that 'with_labels' is not in the draw parameters
        args, kwargs = mock_nx_draw.call_args
        assert 'with_labels' not in kwargs

    # Drawing a graph with edge labels turned on
    def test_draw_with_edge_labels_on(self, mocker):
        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0, label='Node0')
        graph.add_node(1, label='Node1')
        graph.add_edge(0, 1, label='Edge0-1')

        # Act
        draw(graph, with_edge_labels=True)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once_with(graph)
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_nx_draw.assert_called_once()
        mock_nx_draw_edge_labels.assert_called_once()

    # Drawing a graph with both node and edge labels turned on
    def test_draw_with_both_labels_on(self, mocker):

        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0, label='Node0')
        graph.add_node(1, label='Node1')
        graph.add_edge(0, 1, label='Edge0-1')

        # Act
        draw(graph, with_node_labels=True, with_edge_labels=True)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once_with(graph)
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_nx_draw.assert_called_once()
        mock_nx_draw_edge_labels.assert_called_once()

        # Check that node labels are enabled
        args, kwargs = mock_nx_draw.call_args
        assert kwargs.get('with_labels') is True

    # Drawing a planar graph uses planar_layout first
    def test_draw_planar_graph(self, mocker):

        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_planar_layout = mocker.patch('networkx.planar_layout', return_value='planar_pos')
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='spring_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=True)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0)
        graph.add_node(1)
        graph.add_edge(0, 1)

        # Act
        draw(graph)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_planar_layout.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once_with(graph, pos='planar_pos')
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_nx_draw.assert_called_once()

    # Drawing a non-planar graph uses spring_layout directly
    def test_draw_non_planar_graph(self, mocker):

        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_planar_layout = mocker.patch('networkx.planar_layout')
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='spring_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0)
        graph.add_node(1)
        graph.add_edge(0, 1)

        # Act
        draw(graph)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_planar_layout.assert_not_called()
        mock_spring_layout.assert_called_once_with(graph)
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_nx_draw.assert_called_once()

    # Drawing an empty graph
    def test_draw_empty_graph(self, mocker):
        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value={})
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=True)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={})

        graph = nx.Graph()

        # Act
        draw(graph)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once()
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_nx_draw.assert_called_once()

        # Check that node_color is an empty list for empty graph
        args, kwargs = mock_nx_draw.call_args
        assert kwargs.get('node_color') == []

    # Drawing a graph with no node attributes for labels when with_node_labels=True
    def test_draw_no_node_labels_attribute(self, mocker):

        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_get_node_attributes = mocker.patch('networkx.get_node_attributes', return_value={})
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0)  # No label attribute
        graph.add_node(1)  # No label attribute
        graph.add_edge(0, 1)

        # Act
        draw(graph, with_node_labels=True)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once_with(graph)
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_get_node_attributes.assert_called_once_with(graph, 'label')
        mock_nx_draw.assert_called_once()

        # Check that labels parameter is empty dict
        args, kwargs = mock_nx_draw.call_args
        assert kwargs.get('labels') == {}

    # Drawing a graph with no edge attributes for labels when with_edge_labels=True
    def test_draw_no_edge_labels_attribute(self, mocker):

        # Arrange
        mock_nx_draw = mocker.patch('networkx.draw')
        mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
        mock_get_edge_attributes = mocker.patch('networkx.get_edge_attributes', return_value={})
        mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
        mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
        mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
                                               return_value={0: 'red', 1: 'blue'})

        graph = nx.Graph()
        graph.add_node(0)
        graph.add_node(1)
        graph.add_edge(0, 1)  # No label attribute

        # Act
        draw(graph, with_edge_labels=True)

        # Assert
        mock_is_planar.assert_called_once_with(graph)
        mock_spring_layout.assert_called_once_with(graph)
        mock_node_color_mapping.assert_called_once_with(graph)
        mock_get_edge_attributes.assert_called_once_with(graph, 'label')
        mock_nx_draw.assert_called_once()
        mock_nx_draw_edge_labels.assert_called_once()

        # Check that edge_labels parameter is empty dict
        args, kwargs = mock_nx_draw_edge_labels.call_args
        assert kwargs.get('edge_labels') == {}


1		import networkx as nx
2
3		from graphinate.renderers.matplotlib import draw
4
5
6		class TestDraw:
7
8		# Drawing a graph with default parameters (node labels on, edge labels off)
9		def test_draw_with_default_parameters(self, mocker):
10		# Arrange
11		mock_nx_draw = mocker.patch('networkx.draw')
12		mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
13		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
14		mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
15		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
16		return_value={0: 'red', 1: 'blue'})
17
18		graph = nx.Graph()
19		graph.add_node(0, label='Node0')
20		graph.add_node(1, label='Node1')
21		graph.add_edge(0, 1)
22
23		# Act
24		draw(graph)
25
26		# Assert
27		mock_is_planar.assert_called_once_with(graph)
28		mock_spring_layout.assert_called_once_with(graph)
29		mock_node_color_mapping.assert_called_once_with(graph)
30		mock_nx_draw.assert_called_once()
31		mock_nx_draw_edge_labels.assert_not_called()
32
33		# Drawing a graph with node labels turned off
34	View Code Duplication	def test_draw_with_node_labels_off(self, mocker):
		0 ignored issues – show Duplication introduced 2025-04-15 17:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
35		# Arrange
36		mock_nx_draw = mocker.patch('networkx.draw')
37		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
38		mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
39		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
40		return_value={0: 'red', 1: 'blue'})
41
42		graph = nx.Graph()
43		graph.add_node(0, label='Node0')
44		graph.add_node(1, label='Node1')
45		graph.add_edge(0, 1)
46
47		# Act
48		draw(graph, with_node_labels=False)
49
50		# Assert
51		mock_is_planar.assert_called_once_with(graph)
52		mock_spring_layout.assert_called_once_with(graph)
53		mock_node_color_mapping.assert_called_once_with(graph)
54		mock_nx_draw.assert_called_once()
55		# Check that 'with_labels' is not in the draw parameters
56		args, kwargs = mock_nx_draw.call_args
57		assert 'with_labels' not in kwargs
58
59		# Drawing a graph with edge labels turned on
60		def test_draw_with_edge_labels_on(self, mocker):
61		# Arrange
62		mock_nx_draw = mocker.patch('networkx.draw')
63		mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
64		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
65		mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
66		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
67		return_value={0: 'red', 1: 'blue'})
68
69		graph = nx.Graph()
70		graph.add_node(0, label='Node0')
71		graph.add_node(1, label='Node1')
72		graph.add_edge(0, 1, label='Edge0-1')
73
74		# Act
75		draw(graph, with_edge_labels=True)
76
77		# Assert
78		mock_is_planar.assert_called_once_with(graph)
79		mock_spring_layout.assert_called_once_with(graph)
80		mock_node_color_mapping.assert_called_once_with(graph)
81		mock_nx_draw.assert_called_once()
82		mock_nx_draw_edge_labels.assert_called_once()
83
84		# Drawing a graph with both node and edge labels turned on
85	View Code Duplication	def test_draw_with_both_labels_on(self, mocker):
		0 ignored issues – show Duplication introduced 2025-04-15 17:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
86		# Arrange
87		mock_nx_draw = mocker.patch('networkx.draw')
88		mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
89		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
90		mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
91		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
92		return_value={0: 'red', 1: 'blue'})
93
94		graph = nx.Graph()
95		graph.add_node(0, label='Node0')
96		graph.add_node(1, label='Node1')
97		graph.add_edge(0, 1, label='Edge0-1')
98
99		# Act
100		draw(graph, with_node_labels=True, with_edge_labels=True)
101
102		# Assert
103		mock_is_planar.assert_called_once_with(graph)
104		mock_spring_layout.assert_called_once_with(graph)
105		mock_node_color_mapping.assert_called_once_with(graph)
106		mock_nx_draw.assert_called_once()
107		mock_nx_draw_edge_labels.assert_called_once()
108
109		# Check that node labels are enabled
110		args, kwargs = mock_nx_draw.call_args
111		assert kwargs.get('with_labels') is True
112
113		# Drawing a planar graph uses planar_layout first
114	View Code Duplication	def test_draw_planar_graph(self, mocker):
		0 ignored issues – show Duplication introduced 2025-04-15 17:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
115		# Arrange
116		mock_nx_draw = mocker.patch('networkx.draw')
117		mock_planar_layout = mocker.patch('networkx.planar_layout', return_value='planar_pos')
118		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='spring_pos')
119		mock_is_planar = mocker.patch('networkx.is_planar', return_value=True)
120		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
121		return_value={0: 'red', 1: 'blue'})
122
123		graph = nx.Graph()
124		graph.add_node(0)
125		graph.add_node(1)
126		graph.add_edge(0, 1)
127
128		# Act
129		draw(graph)
130
131		# Assert
132		mock_is_planar.assert_called_once_with(graph)
133		mock_planar_layout.assert_called_once_with(graph)
134		mock_spring_layout.assert_called_once_with(graph, pos='planar_pos')
135		mock_node_color_mapping.assert_called_once_with(graph)
136		mock_nx_draw.assert_called_once()
137
138		# Drawing a non-planar graph uses spring_layout directly
139	View Code Duplication	def test_draw_non_planar_graph(self, mocker):
		0 ignored issues – show Duplication introduced 2025-04-15 17:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
140		# Arrange
141		mock_nx_draw = mocker.patch('networkx.draw')
142		mock_planar_layout = mocker.patch('networkx.planar_layout')
143		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='spring_pos')
144		mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
145		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
146		return_value={0: 'red', 1: 'blue'})
147
148		graph = nx.Graph()
149		graph.add_node(0)
150		graph.add_node(1)
151		graph.add_edge(0, 1)
152
153		# Act
154		draw(graph)
155
156		# Assert
157		mock_is_planar.assert_called_once_with(graph)
158		mock_planar_layout.assert_not_called()
159		mock_spring_layout.assert_called_once_with(graph)
160		mock_node_color_mapping.assert_called_once_with(graph)
161		mock_nx_draw.assert_called_once()
162
163		# Drawing an empty graph
164		def test_draw_empty_graph(self, mocker):
165		# Arrange
166		mock_nx_draw = mocker.patch('networkx.draw')
167		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value={})
168		mock_is_planar = mocker.patch('networkx.is_planar', return_value=True)
169		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
170		return_value={})
171
172		graph = nx.Graph()
173
174		# Act
175		draw(graph)
176
177		# Assert
178		mock_is_planar.assert_called_once_with(graph)
179		mock_spring_layout.assert_called_once()
180		mock_node_color_mapping.assert_called_once_with(graph)
181		mock_nx_draw.assert_called_once()
182
183		# Check that node_color is an empty list for empty graph
184		args, kwargs = mock_nx_draw.call_args
185		assert kwargs.get('node_color') == []
186
187		# Drawing a graph with no node attributes for labels when with_node_labels=True
188	View Code Duplication	def test_draw_no_node_labels_attribute(self, mocker):
		0 ignored issues – show Duplication introduced 2025-04-15 17:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
189		# Arrange
190		mock_nx_draw = mocker.patch('networkx.draw')
191		mock_get_node_attributes = mocker.patch('networkx.get_node_attributes', return_value={})
192		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
193		mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
194		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
195		return_value={0: 'red', 1: 'blue'})
196
197		graph = nx.Graph()
198		graph.add_node(0) # No label attribute
199		graph.add_node(1) # No label attribute
200		graph.add_edge(0, 1)
201
202		# Act
203		draw(graph, with_node_labels=True)
204
205		# Assert
206		mock_is_planar.assert_called_once_with(graph)
207		mock_spring_layout.assert_called_once_with(graph)
208		mock_node_color_mapping.assert_called_once_with(graph)
209		mock_get_node_attributes.assert_called_once_with(graph, 'label')
210		mock_nx_draw.assert_called_once()
211
212		# Check that labels parameter is empty dict
213		args, kwargs = mock_nx_draw.call_args
214		assert kwargs.get('labels') == {}
215
216		# Drawing a graph with no edge attributes for labels when with_edge_labels=True
217	View Code Duplication	def test_draw_no_edge_labels_attribute(self, mocker):
		0 ignored issues – show Duplication introduced 2025-04-15 17:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
218		# Arrange
219		mock_nx_draw = mocker.patch('networkx.draw')
220		mock_nx_draw_edge_labels = mocker.patch('networkx.draw_networkx_edge_labels')
221		mock_get_edge_attributes = mocker.patch('networkx.get_edge_attributes', return_value={})
222		mock_spring_layout = mocker.patch('networkx.spring_layout', return_value='mock_pos')
223		mock_is_planar = mocker.patch('networkx.is_planar', return_value=False)
224		mock_node_color_mapping = mocker.patch('graphinate.renderers.matplotlib.node_color_mapping',
225		return_value={0: 'red', 1: 'blue'})
226
227		graph = nx.Graph()
228		graph.add_node(0)
229		graph.add_node(1)
230		graph.add_edge(0, 1) # No label attribute
231
232		# Act
233		draw(graph, with_edge_labels=True)
234
235		# Assert
236		mock_is_planar.assert_called_once_with(graph)
237		mock_spring_layout.assert_called_once_with(graph)
238		mock_node_color_mapping.assert_called_once_with(graph)
239		mock_get_edge_attributes.assert_called_once_with(graph, 'label')
240		mock_nx_draw.assert_called_once()
241		mock_nx_draw_edge_labels.assert_called_once()
242
243		# Check that edge_labels parameter is empty dict
244		args, kwargs = mock_nx_draw_edge_labels.call_args
245		assert kwargs.get('edge_labels') == {}
246

erivlis / graphinate

Push — main ( 88ed15...38252d )

test_matplotlib_draw A

Complexity

Size/Duplication

Importance

9 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like