← Back to branch summary

~ubuntu-branches/ubuntu/natty/pygpgme/natty

« back to all changes in this revision

Viewing changes to gpgme/tests/test_import.py

  • Committer: Bazaar Package Importer
  • Author(s): Miguel Di Ciurcio Filho
  • Date: 2009-07-16 19:30:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090716193000-3bdzvj2oh58z7h24
Tags: upstream-0.1+bzr20090429
Import upstream version 0.1+bzr20090429

Show diffs side-by-side

added added

removed removed

Lines of Context:
gpgme/tests/test_import.py
 
1
# pygpgme - a Python wrapper for the gpgme library
 
2
# Copyright (C) 2006  James Henstridge
 
3
#
 
4
# This library is free software; you can redistribute it and/or
 
5
# modify it under the terms of the GNU Lesser General Public
 
6
# License as published by the Free Software Foundation; either
 
7
# version 2.1 of the License, or (at your option) any later version.
 
8
#
 
9
# This library is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
# Lesser General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU Lesser General Public
 
15
# License along with this library; if not, write to the Free Software
 
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 
 
18
import unittest
 
19
try:
 
20
    from io import BytesIO
 
21
except ImportError:
 
22
    from StringIO import StringIO as BytesIO
 
23
 
 
24
import gpgme
 
25
from gpgme.tests.util import GpgHomeTestCase
 
26
 
 
27
class ImportTestCase(GpgHomeTestCase):
 
28
 
 
29
    def test_import_file(self):
 
30
        fp = self.keyfile('key1.pub')
 
31
        ctx = gpgme.Context()
 
32
        result = ctx.import_(fp)
 
33
        self.assertEqual(result.considered, 1)
 
34
        self.assertEqual(result.no_user_id, 0)
 
35
        self.assertEqual(result.imported, 1)
 
36
        self.assertEqual(result.imported_rsa, 0)
 
37
        self.assertEqual(result.unchanged, 0)
 
38
        self.assertEqual(result.new_user_ids, 0)
 
39
        self.assertEqual(result.new_sub_keys, 0)
 
40
        self.assertEqual(result.new_signatures, 0)
 
41
        self.assertEqual(result.new_revocations, 0)
 
42
        self.assertEqual(result.secret_read, 0)
 
43
        self.assertEqual(result.secret_imported, 0)
 
44
        self.assertEqual(result.secret_unchanged, 0)
 
45
        self.assertEqual(result.skipped_new_keys, 0)
 
46
        self.assertEqual(result.not_imported, 0)
 
47
        self.assertEqual(len(result.imports), 1)
 
48
        self.assertEqual(result.imports[0],
 
49
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4',
 
50
                          None, gpgme.IMPORT_NEW))
 
51
        # can we get the public key?
 
52
        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
 
53
 
 
54
    def test_import_secret_file(self):
 
55
        fp = self.keyfile('key1.sec')
 
56
        ctx = gpgme.Context()
 
57
        result = ctx.import_(fp)
 
58
        self.assertEqual(result.considered, 1)
 
59
        self.assertEqual(result.no_user_id, 0)
 
60
        self.assertEqual(result.imported, 1)
 
61
        self.assertEqual(result.imported_rsa, 0)
 
62
        self.assertEqual(result.unchanged, 0)
 
63
        self.assertEqual(result.new_user_ids, 0)
 
64
        self.assertEqual(result.new_sub_keys, 0)
 
65
        self.assertEqual(result.new_signatures, 0)
 
66
        self.assertEqual(result.new_revocations, 0)
 
67
        self.assertEqual(result.secret_read, 1)
 
68
        self.assertEqual(result.secret_imported, 1)
 
69
        self.assertEqual(result.secret_unchanged, 0)
 
70
        self.assertEqual(result.skipped_new_keys, 0)
 
71
        self.assertEqual(result.not_imported, 0)
 
72
        self.assertEqual(len(result.imports), 2)
 
73
        self.assertEqual(result.imports[0],
 
74
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4',
 
75
                          None, gpgme.IMPORT_NEW | gpgme.IMPORT_SECRET))
 
76
        self.assertEqual(result.imports[1],
 
77
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4',
 
78
                          None, gpgme.IMPORT_NEW))
 
79
        # can we get the public key?
 
80
        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
 
81
        # can we get the secret key?
 
82
        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4', True)
 
83
 
 
84
    def test_import_stringio(self):
 
85
        fp = BytesIO(self.keyfile('key1.pub').read())
 
86
        ctx = gpgme.Context()
 
87
        result = ctx.import_(fp)
 
88
        self.assertEqual(len(result.imports), 1)
 
89
        self.assertEqual(result.imports[0],
 
90
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4',
 
91
                          None, gpgme.IMPORT_NEW))
 
92
        # can we get the public key?
 
93
        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
 
94
 
 
95
    def test_import_concat(self):
 
96
        keys = '\n'.join([self.keyfile('key1.pub').read(),
 
97
                          self.keyfile('key1.sec').read(),
 
98
                          self.keyfile('key2.pub').read()])
 
99
        fp = BytesIO(keys)
 
100
        ctx = gpgme.Context()
 
101
        result = ctx.import_(fp)
 
102
        self.assertEqual(result.considered, 3)
 
103
        self.assertEqual(result.no_user_id, 0)
 
104
        self.assertEqual(result.imported, 2)
 
105
        self.assertEqual(result.imported_rsa, 1)
 
106
        self.assertEqual(result.unchanged, 0)
 
107
        self.assertEqual(result.new_user_ids, 0)
 
108
        self.assertEqual(result.new_sub_keys, 0)
 
109
        self.assertEqual(result.new_signatures, 1)
 
110
        self.assertEqual(result.new_revocations, 0)
 
111
        self.assertEqual(result.secret_read, 1)
 
112
        self.assertEqual(result.secret_imported, 1)
 
113
        self.assertEqual(result.secret_unchanged, 0)
 
114
        self.assertEqual(result.skipped_new_keys, 0)
 
115
        self.assertEqual(result.not_imported, 0)
 
116
        self.assertEqual(len(result.imports), 4)
 
117
        self.assertEqual(result.imports[0],
 
118
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4',
 
119
                          None, gpgme.IMPORT_NEW))
 
120
        self.assertEqual(result.imports[1],
 
121
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4',
 
122
                          None, gpgme.IMPORT_NEW | gpgme.IMPORT_SECRET))
 
123
        self.assertEqual(result.imports[2],
 
124
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4',
 
125
                          None, gpgme.IMPORT_SIG))
 
126
        self.assertEqual(result.imports[3],
 
127
                         ('93C2240D6B8AA10AB28F701D2CF46B7FC97E6B0F',
 
128
                          None, gpgme.IMPORT_NEW))
 
129
        # can we get the public keys?
 
130
        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
 
131
        key = ctx.get_key('93C2240D6B8AA10AB28F701D2CF46B7FC97E6B0F')
 
132
        # can we get the secret key?
 
133
        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4', True)
 
134
 
 
135
    def test_import_empty(self):
 
136
        fp = BytesIO('')
 
137
        ctx = gpgme.Context()
 
138
        result = ctx.import_(fp)
 
139
        self.assertEqual(result.considered, 0)
 
140
        self.assertEqual(len(result.imports), 0)
 
141
 
 
142
    def test_import_twice(self):
 
143
        ctx = gpgme.Context()
 
144
        fp = self.keyfile('key1.pub')
 
145
        result = ctx.import_(fp)
 
146
 
 
147
        fp = self.keyfile('key1.pub')
 
148
        result = ctx.import_(fp)
 
149
 
 
150
        self.assertEqual(result.considered, 1)
 
151
        self.assertEqual(result.no_user_id, 0)
 
152
        self.assertEqual(result.imported, 0)
 
153
        self.assertEqual(result.imported_rsa, 0)
 
154
        self.assertEqual(result.unchanged, 1)
 
155
        self.assertEqual(result.new_user_ids, 0)
 
156
        self.assertEqual(result.new_sub_keys, 0)
 
157
        self.assertEqual(result.new_signatures, 0)
 
158
        self.assertEqual(result.new_revocations, 0)
 
159
        self.assertEqual(result.secret_read, 0)
 
160
        self.assertEqual(result.secret_imported, 0)
 
161
        self.assertEqual(result.secret_unchanged, 0)
 
162
        self.assertEqual(result.skipped_new_keys, 0)
 
163
        self.assertEqual(result.not_imported, 0)
 
164
        self.assertEqual(len(result.imports), 1)
 
165
        self.assertEqual(result.imports[0],
 
166
                         ('E79A842DA34A1CA383F64A1546BB55F0885C65A4', None, 0))
 
167
        # can we get the public key?
 
168
        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
 
169
 
 
170
def test_suite():
 
171
    loader = unittest.TestLoader()
 
172
    return loader.loadTestsFromName(__name__)