Coverage for core\test_leoPersistence.py: 100%

135 statements  

« prev     ^ index     » next       coverage.py v6.4, created at 2022-05-24 10:21 -0500

1# -*- coding: utf-8 -*- 

2#@+leo-ver=5-thin 

3#@+node:ekr.20210908171733.1: * @file ../unittests/core/test_leoPersistence.py 

4#@@first 

5"""Tests for leo.core.leoPersistence""" 

6 

7from leo.core import leoGlobals as g 

8from leo.core.leoTest2 import LeoUnitTest 

9assert g 

10 

11#@+others 

12#@+node:ekr.20210908171733.2: ** class TestPersistence(LeoUnitTest) 

13class TestPersistence(LeoUnitTest): 

14 """Unit tests for leo/core/leoPersistence.py.""" 

15 #@+others 

16 #@+node:ekr.20210908173748.1: *3* TestPersistence.create_test_outline 

17 def create_test_outline(self): 

18 c = self.c 

19 # Add an @settings, @persistence and @gnx nodes. 

20 settings_p = c.lastTopLevel() 

21 settings_p.b = '@settings' 

22 persistence_p = settings_p.insertAfter() 

23 persistence_p.h = '@persistence' 

24 gnx_p = persistence_p.insertAsLastChild() 

25 gnx_p.h = '@gnxs' 

26 gnx_p.b = ( 

27 'gnx: ekr.20140923080452\n' 

28 'unl: node1\n' 

29 ) 

30 #@+node:ekr.20210908171733.3: *3* TestPersistence.setUp 

31 def setUp(self): 

32 """Create the nodes in the commander.""" 

33 super().setUp() 

34 c = self.c 

35 self.create_test_outline() 

36 c.selectPosition(c.rootPosition()) 

37 #@+node:ekr.20210908172651.44: *3* TestPersistence.test_delete_all_children_of_persistence_node 

38 def test_delete_all_children_of_persistence_node(self): 

39 c, pd = self.c, self.c.persistenceController 

40 persistence = g.findNodeAnywhere(c, '@persistence') 

41 assert persistence 

42 assert pd.has_at_persistence_node() 

43 persistence.deleteAllChildren() 

44 assert persistence 

45 #@+node:ekr.20210908172651.2: *3* TestPersistence.test_p_sort_key 

46 def test_p_sort_key(self): 

47 c, p = self.c, self.c.p 

48 aList = [z.copy() for z in c.all_positions()] 

49 aList2 = sorted(reversed(aList), key=p.sort_key) 

50 for i, p in enumerate(aList2): 

51 p2 = aList[i] 

52 self.assertEqual(p, p2, msg=f"i: {i}, p.h: {p.h}. p2: {p2.h}") 

53 #@+node:ekr.20210908172651.3: *3* TestPersistence.test_pd_find_at_data_and gnxs_nodes 

54 def test_pd_find_at__(self): 

55 pd = self.c.persistenceController 

56 # Also a test of find_at_views_node, find_at_organizers_node and find_at_clones_node. 

57 persistence = pd.find_at_persistence_node() 

58 assert persistence 

59 persistence.deleteAllChildren() 

60 root = self.root_p 

61 root.h = '@auto root' # Make root look like an @auto node. 

62 assert pd.find_at_data_node(root) 

63 assert pd.find_at_gnxs_node(root) 

64 #@+node:ekr.20210908172651.9: *3* TestPersistence.test_pd_find_position_for_relative_unl 

65 def test_pd_find_position_for_relative_unl(self): 

66 p, pd = self.c.p, self.c.persistenceController 

67 parent = p.copy() 

68 # node1 

69 node1 = parent.insertAsLastChild() 

70 node1.h = 'node1' 

71 child11 = node1.insertAsLastChild() 

72 child11.h = 'child11' 

73 child12 = node1.insertAsLastChild() 

74 child12.h = 'child12' 

75 # node2 

76 node2 = parent.insertAsLastChild() 

77 node2.h = 'node2' 

78 child21 = node2.insertAsLastChild() 

79 child21.h = 'child21' 

80 child22 = node2.insertAsLastChild() 

81 child22.h = 'child22' 

82 # node3 

83 node3 = parent.insertAsLastChild() 

84 node3.h = 'node3' 

85 table = ( 

86 ('', parent), # Important special case. 

87 ('node1-->child11', child11), 

88 ('node1-->child12', child12), 

89 ('node2', node2), 

90 ('node2-->child21', child21), 

91 ('node2-->child22', child22), 

92 # Partial matches. 

93 # ('node3-->child1-->child21',node3_child1_child21), 

94 # ('child1-->child21',node3_child1_child21), 

95 # ('xxx-->child21',node3_child1_child21), 

96 # This is ambiguous. 

97 # No matches. 

98 ('nodex', None), 

99 ('node1-->childx', None), 

100 ('node3-->childx', None), 

101 ) 

102 for unl, expected in table: 

103 result = pd.find_position_for_relative_unl(parent, unl) 

104 self.assertEqual(result, expected, msg=unl) 

105 #@+node:ekr.20210908172651.19: *3* TestPersistence.test_pd_find_representative_node 

106 def test_pd_find_representative_node(self): 

107 pd = self.c.persistenceController 

108 root = self.root_p 

109 root.h = '@auto root' 

110 inner_clone = root.insertAsLastChild() 

111 inner_clone.h = 'clone' 

112 outer_clone = inner_clone.clone() 

113 outer_clone.moveAfter(root) 

114 rep = pd.find_representative_node(root, inner_clone) 

115 assert rep 

116 self.assertEqual(rep, outer_clone) 

117 #@+node:ekr.20210908172651.23: *3* TestPersistence.test_pd_has_at_gnxs_node 

118 def test_pd_has_at_gnxs_node(self): 

119 c, pd = self.c, self.c.persistenceController 

120 # Set up the tree. 

121 root = self.root_p 

122 root.h = '@auto root' # Make root look like an @auto node. 

123 inner_clone = root.insertAsLastChild() 

124 inner_clone.h = 'clone' 

125 outer_clone = inner_clone.clone() 

126 outer_clone.moveAfter(root) 

127 # Test the tree. 

128 persistence = g.findNodeAnywhere(c, '@persistence') 

129 assert persistence 

130 assert pd.has_at_persistence_node() 

131 # Update the tree. 

132 persistence.deleteAllChildren() # Required 

133 assert persistence 

134 pd.update_before_write_foreign_file(root) 

135 data = g.findNodeInTree(c, persistence, '@data:@auto root') 

136 assert data 

137 data2 = pd.has_at_data_node(root) 

138 assert data2 

139 self.assertEqual(data, data2, (data, data2)) 

140 gnxs = g.findNodeInTree(c, persistence, '@gnxs') 

141 assert gnxs 

142 gnxs2 = pd.has_at_gnxs_node(root) 

143 assert gnxs2 

144 self.assertEqual(gnxs, gnxs2, (gnxs, gnxs2)) 

145 #@+node:ekr.20210908172651.30: *3* TestPersistence.test_pd_restore_gnxs 

146 def test_pd_restore_gnxs(self): 

147 c, pd = self.c, self.c.persistenceController 

148 root = self.root_p 

149 # Set up the tree. 

150 persistence = g.findNodeAnywhere(c, '@persistence') 

151 assert persistence 

152 gnxs = g.findNodeAnywhere(c, '@gnxs') 

153 assert gnxs 

154 inner_clone = root.insertAsLastChild() 

155 inner_clone.h = 'clone' 

156 outer_clone = inner_clone.clone() 

157 outer_clone.moveAfter(root) 

158 node1 = root.insertAsLastChild() 

159 node1.h = 'node1' 

160 # Test. 

161 root.deleteAllChildren() 

162 pd.restore_gnxs(gnxs, root) 

163 #@+node:ekr.20210908172651.35: *3* TestPersistence.test_pd_unl 

164 def test_pd_unl(self): 

165 c, pd = self.c, self.c.persistenceController 

166 root = self.root_p 

167 node1 = root.insertAsLastChild() 

168 node1.h = 'node1' 

169 c.selectPosition(node1) 

170 unl = pd.unl(c.p) 

171 expected = f"-->{c.p.h}" 

172 assert unl.endswith(expected), repr(unl) 

173 #@+node:ekr.20210908172651.36: *3* TestPersistence.test_pd_update_before_write_foreign_file 

174 def test_pd_update_before_write_foreign_file(self): 

175 c, pd = self.c, self.c.persistenceController 

176 root = self.root_p 

177 assert root 

178 persistence = pd.find_at_persistence_node() 

179 assert persistence 

180 persistence.deleteAllChildren() 

181 root.h = '@auto root' # Make root look like an @auto node. 

182 pd.update_before_write_foreign_file(root) 

183 data = g.findNodeAnywhere(c, '@data:@auto root') 

184 assert data 

185 gnxs = g.findNodeInTree(c, data, '@gnxs') 

186 assert gnxs 

187 #@-others 

188#@-others 

189 

190#@-leo