call site 6 for path.local.sysfind
misc/testing/test_initpkg.py - line 83
81
82
83
   def check_import(modpath): 
       print "checking import", modpath
->     assert __import__(modpath) 
path/testing/test_api.py - line 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
   from py import path, test
   import py
-> from py.__.path.svn.testing.test_wccommand import getrepowc
   
   class TestAPI:
   
       def setup_class(cls): 
           cls.root = py.test.ensuretemp(cls.__name__) 
   
       def repr_eval_test(self, p):
           r = repr(p)
           from py.path import local,svnurl, svnwc
           y = eval(r)
           assert y == p
   
       def test_defaultlocal(self):
           p = path.local()
           assert hasattr(p, 'atime')
           #assert hasattr(p, 'group') # XXX win32? 
           assert hasattr(p, 'setmtime')
           assert p.check()
           assert p.check(local=1)
           assert p.check(svnwc=0)
           assert not p.check(svnwc=1)
           self.repr_eval_test(p)
   
           #assert p.std.path()
   
       def test_local(self):
           p = path.local()
           assert hasattr(p, 'atime')
           assert hasattr(p, 'setmtime')
           assert p.check()
           assert p.check(local=1)
           self.repr_eval_test(p)
   
       def test_svnurl(self):
           p = path.svnurl('http://codespeak.net/svn/py')
           assert p.check(svnurl=1)
           self.repr_eval_test(p)
   
       def test_svnwc(self):
           p = path.svnwc(self.root)
           assert p.check(svnwc=1)
           self.repr_eval_test(p)
path/svn/testing/test_wccommand.py - line 8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
   import py
   from py.__.path.svn.testing.svntestbase import CommonSvnTests, getrepowc
   from py.__.path.svn.wccommand import InfoSvnWCCommand
   from py.__.path.svn.wccommand import parse_wcinfotime
   from py.__.path.svn import svncommon
   
   
-> if py.path.local.sysfind('svn') is None:
       py.test.skip("cannot test py.path.svn, 'svn' binary not found")
   
   
   class TestWCSvnCommandPath(CommonSvnTests):
   
       def setup_class(cls): 
           repo, cls.root = getrepowc()
   
       def test_move_file(self):  # overrides base class
           try:
               super(TestWCSvnCommandPath, self).test_move_file()
           finally:
               self.root.revert(rec=1)
   
       def test_move_directory(self): # overrides base class
           try:
               super(TestWCSvnCommandPath, self).test_move_directory()
           finally:
               self.root.revert(rec=1)
   
       def test_status_attributes_simple(self):
           def assert_nochange(p):
               s = p.status()
               assert not s.modified
               assert not s.prop_modified
               assert not s.added
               assert not s.deleted
   
           dpath = self.root.join('sampledir')
           assert_nochange(self.root.join('sampledir'))
           assert_nochange(self.root.join('samplefile'))
   
       def test_status_added(self):
           nf = self.root.join('newfile')
           nf.write('hello')
           nf.add()
           try:
               s = nf.status()
               assert s.added
               assert not s.modified
               assert not s.prop_modified
           finally:
               nf.revert()
   
       def test_status_change(self):
           nf = self.root.join('samplefile')
           try:
               nf.write(nf.read() + 'change')
               s = nf.status()
               assert not s.added
               assert s.modified
               assert not s.prop_modified
           finally:
               nf.revert()
   
       def test_status_added_ondirectory(self):
           sampledir = self.root.join('sampledir')
           try:
               t2 = sampledir.mkdir('t2')
               t1 = t2.join('t1')
               t1.write('test')
               t1.add()
               s = sampledir.status(rec=1)
               # Comparing just the file names, because paths are unpredictable
               # on Windows. (long vs. 8.3 paths)
               assert t1.basename in [item.basename for item in s.added]
               assert t2.basename in [item.basename for item in s.added]
           finally:
               t2.revert(rec=1)
               t2.localpath.remove(rec=1)
   
       def test_status_unknown(self):
           t1 = self.root.join('un1')
           try:
               t1.write('test')
               s = self.root.status()
               # Comparing just the file names, because paths are unpredictable
               # on Windows. (long vs. 8.3 paths)
               assert t1.basename in [item.basename for item in s.unknown]
           finally:
               t1.localpath.remove()
   
       def test_status_unchanged(self):
           r = self.root
           s = self.root.status(rec=1)
           # Comparing just the file names, because paths are unpredictable
           # on Windows. (long vs. 8.3 paths)
           assert r.join('samplefile').basename in [item.basename 
                                                       for item in s.unchanged]
           assert r.join('sampledir').basename in [item.basename 
                                                       for item in s.unchanged]
           assert r.join('sampledir/otherfile').basename in [item.basename 
                                                       for item in s.unchanged]
   
       def test_status_update(self):
           r = self.root
           try:
               r.update(rev=1)
               s = r.status(updates=1, rec=1)
               # Comparing just the file names, because paths are unpredictable
               # on Windows. (long vs. 8.3 paths)
               assert r.join('anotherfile').basename in [item.basename for 
                                                       item in s.update_available]
               #assert len(s.update_available) == 1
           finally:
               r.update()
   
       def test_diff(self):
           p = self.root / 'anotherfile'
           out = p.diff(rev=2)
           assert out.find('hello') != -1
   
       def test_blame(self):
           p = self.root.join('samplepickle')
           lines = p.blame()
           assert sum([l[0] for l in lines]) == len(lines)
           for l1, l2 in zip(p.readlines(), [l[2] for l in lines]):
               assert l1 == l2
           assert [l[1] for l in lines] == ['hpk'] * len(lines)
           p = self.root.join('samplefile')
           lines = p.blame()
           assert sum([l[0] for l in lines]) == len(lines)
           for l1, l2 in zip(p.readlines(), [l[2] for l in lines]):
               assert l1 == l2
           assert [l[1] for l in lines] == ['hpk'] * len(lines)
   
       def test_join_abs(self):
           s = str(self.root.localpath)
           n = self.root.join(s, abs=1)
           assert self.root == n
   
       def test_join_abs2(self):
           assert self.root.join('samplefile', abs=1) == self.root.join('samplefile')
   
       def test_str_gives_localpath(self):
           assert str(self.root) == str(self.root.localpath)
   
       def test_versioned(self):
           assert self.root.check(versioned=1)
           # TODO: Why does my copy of svn think .svn is versioned?
           #assert self.root.join('.svn').check(versioned=0) 
           assert self.root.join('samplefile').check(versioned=1)
           assert not self.root.join('notexisting').check(versioned=1)
           notexisting = self.root.join('hello').localpath
           try:
               notexisting.write("")
               assert self.root.join('hello').check(versioned=0)
           finally:
               notexisting.remove()
   
       def test_properties(self):
           try:
               self.root.propset('gaga', 'this')
               assert self.root.propget('gaga') == 'this'
               # Comparing just the file names, because paths are unpredictable
               # on Windows. (long vs. 8.3 paths)
               assert self.root.basename in [item.basename for item in 
                                           self.root.status().prop_modified]
               assert 'gaga' in self.root.proplist()
               assert self.root.proplist()['gaga'] == 'this'
   
           finally:
               self.root.propdel('gaga')
   
       def test_proplist_recursive(self):
           s = self.root.join('samplefile')
           s.propset('gugu', 'that')
           try:
               p = self.root.proplist(rec=1)
               # Comparing just the file names, because paths are unpredictable
               # on Windows. (long vs. 8.3 paths)
               assert (self.root / 'samplefile').basename in [item.basename 
                                                                   for item in p]
           finally:
               s.propdel('gugu')
   
       def test_long_properties(self):
           value = """
           vadm:posix : root root 0100755
           Properties on 'chroot/dns/var/bind/db.net.xots':
                   """
           try:
               self.root.propset('gaga', value)
               backvalue = self.root.propget('gaga')
               assert backvalue == value
               #assert len(backvalue.split('\n')) == 1
           finally:
               self.root.propdel('gaga')
   
   
       def test_ensure(self):
           newpath = self.root.ensure('a', 'b', 'c')
           try:
               assert newpath.check(exists=1, versioned=1)
               newpath.write("hello")
               newpath.ensure()
               assert newpath.read() == "hello"
           finally:
               self.root.join('a').remove(force=1)
   
       def test_not_versioned(self):
           p = self.root.localpath.mkdir('whatever')
           f = self.root.localpath.ensure('testcreatedfile')
           try:
               assert self.root.join('whatever').check(versioned=0)
               assert self.root.join('testcreatedfile').check(versioned=0)
               assert not self.root.join('testcreatedfile').check(versioned=1)
           finally:
               p.remove(rec=1)
               f.remove()