Merge lp:~jml/pkgme-devportal/remove-package-database into lp:pkgme-devportal
- remove-package-database
- Merge into trunk
Proposed by
Jonathan Lange
Status: | Merged |
---|---|
Merged at revision: | 146 |
Proposed branch: | lp:~jml/pkgme-devportal/remove-package-database |
Merge into: | lp:pkgme-devportal |
Prerequisite: | lp:~jml/pkgme-devportal/remove-database-code |
Diff against target: |
451 lines (+7/-363) 4 files modified
devportalbinary/database.py (+0/-122) devportalbinary/testing.py (+3/-139) devportalbinary/tests/test_database.py (+2/-102) setup.py (+2/-0) |
To merge this branch: | bzr merge lp:~jml/pkgme-devportal/remove-package-database |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
pkgme binary committers | Pending | ||
Review via email: mp+134102@code.launchpad.net |
Commit message
Remove PackageDatabase and a bunch of test code.
Description of the change
Slowly killing things.
To post a comment you must log in.
- 178. By Jonathan Lange
-
More things that we don't need.
- 179. By Jonathan Lange
-
Merge changes from trunk.
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1 | === modified file 'devportalbinary/database.py' | |||
2 | --- devportalbinary/database.py 2012-11-13 14:35:23 +0000 | |||
3 | +++ devportalbinary/database.py 2012-11-13 14:35:23 +0000 | |||
4 | @@ -1,135 +1,13 @@ | |||
5 | 1 | # Copyright 2011 Canonical Ltd. This software is licensed under the | 1 | # Copyright 2011 Canonical Ltd. This software is licensed under the |
6 | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). |
7 | 3 | 3 | ||
8 | 4 | from storm.expr import And, Column, Select, Table | ||
9 | 5 | from storm.locals import create_database, Store | ||
10 | 6 | from storm.uri import URI as StormURI | ||
11 | 7 | |||
12 | 8 | from .configuration import ( | 4 | from .configuration import ( |
13 | 9 | CONF_FILE_ENV_VAR, | ||
14 | 10 | get_config_file_path, | ||
15 | 11 | load_configuration, | 5 | load_configuration, |
16 | 12 | ) | 6 | ) |
17 | 13 | 7 | ||
18 | 14 | from libdep_service_client.client import Client | 8 | from libdep_service_client.client import Client |
19 | 15 | 9 | ||
20 | 16 | 10 | ||
21 | 17 | class URI(StormURI): | ||
22 | 18 | """A stand-in for Storm's URI class. | ||
23 | 19 | |||
24 | 20 | This class implements the same interface as `storm.uri.URI`, except | ||
25 | 21 | that the constructor has a different signature. Storm's version takes | ||
26 | 22 | a string and parses it, this version can be used when you already | ||
27 | 23 | have a parsed version and just need to create the object. | ||
28 | 24 | """ | ||
29 | 25 | |||
30 | 26 | # XXX: Only used by PackageDatabase, which is flagged for deletion. | ||
31 | 27 | |||
32 | 28 | def __init__(self, scheme=None, host=None, port=None, username=None, | ||
33 | 29 | password=None, database=None, options=None): | ||
34 | 30 | self.scheme = scheme | ||
35 | 31 | self.host = host | ||
36 | 32 | self.port = port | ||
37 | 33 | self.username = username | ||
38 | 34 | self.password = password | ||
39 | 35 | self.database = database | ||
40 | 36 | self.options = options | ||
41 | 37 | if self.options is None: | ||
42 | 38 | self.options = dict() | ||
43 | 39 | |||
44 | 40 | |||
45 | 41 | class PackageDatabase(object): | ||
46 | 42 | |||
47 | 43 | # XXX: No longer used within pkgme-devportal | ||
48 | 44 | |||
49 | 45 | SQLITE = 'sqlite' | ||
50 | 46 | POSTGRES = 'postgres' | ||
51 | 47 | |||
52 | 48 | def __init__(self, store): | ||
53 | 49 | self._store = store | ||
54 | 50 | |||
55 | 51 | @classmethod | ||
56 | 52 | def _get_storm_sqlite_connection_uri(cls, opts): | ||
57 | 53 | raise ValueError( | ||
58 | 54 | "SQLite is no longer supported, you must migrate to postgresql.") | ||
59 | 55 | |||
60 | 56 | @classmethod | ||
61 | 57 | def _get_storm_postgres_connection_uri(cls, opts): | ||
62 | 58 | if not getattr(opts, 'database_db_name', None): | ||
63 | 59 | raise ValueError( | ||
64 | 60 | "Can't create database, no connection info available. " | ||
65 | 61 | "You must specify %s. Looked in %s. " | ||
66 | 62 | "Perhaps %s is set incorrectly?" % ( | ||
67 | 63 | 'db_name', get_config_file_path(), CONF_FILE_ENV_VAR)) | ||
68 | 64 | return URI(scheme=opts.database_db_type, | ||
69 | 65 | username=opts.database_username, | ||
70 | 66 | password=opts.database_password, | ||
71 | 67 | host=opts.database_host, | ||
72 | 68 | port=opts.database_port, | ||
73 | 69 | database=opts.database_db_name) | ||
74 | 70 | |||
75 | 71 | @classmethod | ||
76 | 72 | def _get_storm_connection_uri(cls, opts): | ||
77 | 73 | if opts.database_db_type == cls.POSTGRES: | ||
78 | 74 | return cls._get_storm_postgres_connection_uri(opts) | ||
79 | 75 | elif opts.database_db_type == cls.SQLITE: | ||
80 | 76 | return cls._get_storm_sqlite_connection_uri(opts) | ||
81 | 77 | else: | ||
82 | 78 | raise AssertionError( | ||
83 | 79 | "Unsupported database: %s" % opts.database_db_type) | ||
84 | 80 | |||
85 | 81 | @classmethod | ||
86 | 82 | def get_db_info_from_config(cls, opts): | ||
87 | 83 | return cls._get_storm_connection_uri(opts) | ||
88 | 84 | |||
89 | 85 | @classmethod | ||
90 | 86 | def get_store_from_config(cls, opts): | ||
91 | 87 | """Create a storm store based on a config file. | ||
92 | 88 | |||
93 | 89 | This method will create a storm store based | ||
94 | 90 | on the information in ``~/.config/pkgme-binary/conf`` | ||
95 | 91 | |||
96 | 92 | :return: a tuple of (store, store_type), where store_type | ||
97 | 93 | is one of cls.SQLITE or cls.POSTGRES, indicating what | ||
98 | 94 | is at the other end of the store. | ||
99 | 95 | """ | ||
100 | 96 | connection_info = cls.get_db_info_from_config(opts) | ||
101 | 97 | database = create_database(connection_info) | ||
102 | 98 | return Store(database) | ||
103 | 99 | |||
104 | 100 | @classmethod | ||
105 | 101 | def from_options(cls, options): | ||
106 | 102 | return cls(cls.get_store_from_config(options)) | ||
107 | 103 | |||
108 | 104 | def _get_query(self, library_names, arch): | ||
109 | 105 | return Select( | ||
110 | 106 | [Column('library'), Column('dependency')], | ||
111 | 107 | And(Column('architecture') == arch, | ||
112 | 108 | Column('library').is_in(map(unicode, library_names))), | ||
113 | 109 | Table('libdep')) | ||
114 | 110 | |||
115 | 111 | def get_multiple_dependencies(self, library_names, arch): | ||
116 | 112 | """Get the binary packages that provide libraries. | ||
117 | 113 | |||
118 | 114 | :return: (deps, missing), where ``deps`` is a dict mapping library | ||
119 | 115 | names to sets of packages that provide them, and ``missing`` is a | ||
120 | 116 | set of library names for which no dependencies could be found. | ||
121 | 117 | """ | ||
122 | 118 | arch = unicode(arch) | ||
123 | 119 | result = self._store.execute(self._get_query(library_names, arch)) | ||
124 | 120 | found = {} | ||
125 | 121 | for row in result: | ||
126 | 122 | [lib, dependency] = row | ||
127 | 123 | if lib in found: | ||
128 | 124 | found[lib].add(dependency) | ||
129 | 125 | else: | ||
130 | 126 | found[lib] = set([dependency]) | ||
131 | 127 | return found | ||
132 | 128 | |||
133 | 129 | def close(self): | ||
134 | 130 | self._store.close() | ||
135 | 131 | |||
136 | 132 | |||
137 | 133 | class LibdepServiceClient(object): | 11 | class LibdepServiceClient(object): |
138 | 134 | """Implements the read part of PackageDatabase's interface.""" | 12 | """Implements the read part of PackageDatabase's interface.""" |
139 | 135 | 13 | ||
140 | 136 | 14 | ||
141 | === modified file 'devportalbinary/testing.py' | |||
142 | --- devportalbinary/testing.py 2012-11-13 11:12:08 +0000 | |||
143 | +++ devportalbinary/testing.py 2012-11-13 14:35:23 +0000 | |||
144 | @@ -1,7 +1,6 @@ | |||
145 | 1 | # Copyright 2011-2012 Canonical Ltd. This software is licensed under the | 1 | # Copyright 2011-2012 Canonical Ltd. This software is licensed under the |
146 | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). |
147 | 3 | 3 | ||
148 | 4 | from contextlib import closing | ||
149 | 5 | import json | 4 | import json |
150 | 6 | import os | 5 | import os |
151 | 7 | import random | 6 | import random |
152 | @@ -21,11 +20,6 @@ | |||
153 | 21 | Fixture, | 20 | Fixture, |
154 | 22 | TempDir, | 21 | TempDir, |
155 | 23 | ) | 22 | ) |
156 | 24 | from postgresfixture import ClusterFixture | ||
157 | 25 | from storm.locals import create_database, Store | ||
158 | 26 | from testresources import ( | ||
159 | 27 | FixtureResource as _FixtureResource, | ||
160 | 28 | ) | ||
161 | 29 | from testtools import TestCase | 23 | from testtools import TestCase |
162 | 30 | from treeshape import ( | 24 | from treeshape import ( |
163 | 31 | from_rough_spec, | 25 | from_rough_spec, |
164 | @@ -33,11 +27,7 @@ | |||
165 | 33 | ) | 27 | ) |
166 | 34 | 28 | ||
167 | 35 | from devportalbinary.binary import MetadataBackend | 29 | from devportalbinary.binary import MetadataBackend |
173 | 36 | from devportalbinary.database import ( | 30 | from devportalbinary.database import LibdepServiceClient |
169 | 37 | LibdepServiceClient, | ||
170 | 38 | PackageDatabase, | ||
171 | 39 | URI, | ||
172 | 40 | ) | ||
174 | 41 | 31 | ||
175 | 42 | from devportalbinary.configuration import CONF_FILE_ENV_VAR | 32 | from devportalbinary.configuration import CONF_FILE_ENV_VAR |
176 | 43 | 33 | ||
177 | @@ -90,133 +80,6 @@ | |||
178 | 90 | im.size[0], im.size[1], im.format)) | 80 | im.size[0], im.size[1], im.format)) |
179 | 91 | 81 | ||
180 | 92 | 82 | ||
181 | 93 | def get_db_schema_file_path(name): | ||
182 | 94 | return os.path.join(os.path.dirname( | ||
183 | 95 | os.path.abspath(__file__)), 'db', name) | ||
184 | 96 | |||
185 | 97 | |||
186 | 98 | def get_db_schema_queries(filenames): | ||
187 | 99 | for filename in filenames: | ||
188 | 100 | path = get_db_schema_file_path(filename) | ||
189 | 101 | with open(path) as f: | ||
190 | 102 | yield f.read() | ||
191 | 103 | |||
192 | 104 | |||
193 | 105 | class PostgresDatabaseFixture(Fixture): | ||
194 | 106 | |||
195 | 107 | def __init__(self): | ||
196 | 108 | super(PostgresDatabaseFixture, self).__init__() | ||
197 | 109 | self.db_name = "libdep" | ||
198 | 110 | |||
199 | 111 | def drop_db(self): | ||
200 | 112 | # stub suggests that dropping all tables would be quicker than | ||
201 | 113 | # dropping the db when the number of tables is small. | ||
202 | 114 | # select quote_ident(table_schema) || '.' || | ||
203 | 115 | # quote_ident(table_name) from information_schema.tables | ||
204 | 116 | # WHERE table_schema = 'public'; | ||
205 | 117 | self.cluster.dropdb(self.db_name) | ||
206 | 118 | |||
207 | 119 | def create_db(self): | ||
208 | 120 | self.cluster.createdb(self.db_name) | ||
209 | 121 | queries = [ | ||
210 | 122 | 'postgres_schema.sql', | ||
211 | 123 | 'patch-00001.sql', | ||
212 | 124 | 'patch-00002.sql', | ||
213 | 125 | ] | ||
214 | 126 | for patch in get_db_schema_queries(queries): | ||
215 | 127 | self._execute(patch) | ||
216 | 128 | |||
217 | 129 | def _execute(self, query): | ||
218 | 130 | with closing(self.cluster.connect(self.db_name)) as conn: | ||
219 | 131 | cur = conn.cursor() | ||
220 | 132 | cur.execute(query) | ||
221 | 133 | conn.commit() | ||
222 | 134 | |||
223 | 135 | def close_connection(self): | ||
224 | 136 | self.conn.close() | ||
225 | 137 | |||
226 | 138 | def open_connection(self): | ||
227 | 139 | db = create_database(URI(scheme='postgres', | ||
228 | 140 | host=self.cluster.datadir, database=self.db_name)) | ||
229 | 141 | self.conn = Store(db) | ||
230 | 142 | self.addCleanup(self.close_connection) | ||
231 | 143 | |||
232 | 144 | def reset(self): | ||
233 | 145 | self.close_connection() | ||
234 | 146 | self.drop_db() | ||
235 | 147 | self.create_db() | ||
236 | 148 | self.open_connection() | ||
237 | 149 | |||
238 | 150 | def setUp(self): | ||
239 | 151 | super(PostgresDatabaseFixture, self).setUp() | ||
240 | 152 | self.tempdir = self.useFixture(TempDir()) | ||
241 | 153 | self.cluster = self.useFixture(ClusterFixture(self.tempdir.path)) | ||
242 | 154 | self.create_db() | ||
243 | 155 | self.open_connection() | ||
244 | 156 | |||
245 | 157 | |||
246 | 158 | class FixtureResource(_FixtureResource): | ||
247 | 159 | """The built in FixtureResource doesn't get properly dirtied.""" | ||
248 | 160 | # XXX: workaround for bug 1023423 | ||
249 | 161 | |||
250 | 162 | def _get_dirty(self): | ||
251 | 163 | return True | ||
252 | 164 | |||
253 | 165 | def _set_dirty(self, new_val): | ||
254 | 166 | pass | ||
255 | 167 | |||
256 | 168 | _dirty = property(_get_dirty, _set_dirty) | ||
257 | 169 | |||
258 | 170 | |||
259 | 171 | class PostgresDatabaseResource(FixtureResource): | ||
260 | 172 | |||
261 | 173 | def __init__(self): | ||
262 | 174 | fixture = PostgresDatabaseFixture() | ||
263 | 175 | super(PostgresDatabaseResource, self).__init__(fixture) | ||
264 | 176 | |||
265 | 177 | def reset(self, resource, result=None): | ||
266 | 178 | resource.reset() | ||
267 | 179 | return resource | ||
268 | 180 | |||
269 | 181 | |||
270 | 182 | postgres_db_resource = PostgresDatabaseResource() | ||
271 | 183 | |||
272 | 184 | |||
273 | 185 | class DatabaseConfig(Fixture): | ||
274 | 186 | |||
275 | 187 | def __init__(self, db_fixture): | ||
276 | 188 | super(DatabaseConfig, self).__init__() | ||
277 | 189 | self.db_fixture = db_fixture | ||
278 | 190 | |||
279 | 191 | def setUp(self): | ||
280 | 192 | super(DatabaseConfig, self).setUp() | ||
281 | 193 | self.useFixture( | ||
282 | 194 | ConfigSettings( | ||
283 | 195 | ('database', {'db_type': 'postgres', | ||
284 | 196 | 'host': self.db_fixture.cluster.datadir, | ||
285 | 197 | 'db_name': self.db_fixture.db_name, | ||
286 | 198 | }))) | ||
287 | 199 | |||
288 | 200 | |||
289 | 201 | class DatabaseFixture(Fixture): | ||
290 | 202 | """Create a temporary database and make it the default. | ||
291 | 203 | |||
292 | 204 | Don't use this twice within a test, otherwise you'll get confused. | ||
293 | 205 | """ | ||
294 | 206 | |||
295 | 207 | def setUp(self): | ||
296 | 208 | super(DatabaseFixture, self).setUp() | ||
297 | 209 | pg_db = self.useFixture(PostgresDatabaseFixture()) | ||
298 | 210 | self.useFixture(DatabaseConfig(pg_db)) | ||
299 | 211 | self.db = PackageDatabase(pg_db.conn) | ||
300 | 212 | self.addCleanup(self.db.close) | ||
301 | 213 | |||
302 | 214 | |||
303 | 215 | def ConfigFileFixture(location): | ||
304 | 216 | """Use a different configuration file.""" | ||
305 | 217 | return EnvironmentVariableFixture(CONF_FILE_ENV_VAR, location) | ||
306 | 218 | |||
307 | 219 | |||
308 | 220 | class ConfigSettings(Fixture): | 83 | class ConfigSettings(Fixture): |
309 | 221 | """Use a configuration file with different settings.""" | 84 | """Use a configuration file with different settings.""" |
310 | 222 | 85 | ||
311 | @@ -239,7 +102,8 @@ | |||
312 | 239 | tempdir = self.useFixture(TempDir()) | 102 | tempdir = self.useFixture(TempDir()) |
313 | 240 | config_file_path = os.path.join(tempdir.path, 'test.cfg') | 103 | config_file_path = os.path.join(tempdir.path, 'test.cfg') |
314 | 241 | write_config_file(config_file_path, self._settings) | 104 | write_config_file(config_file_path, self._settings) |
316 | 242 | self.useFixture(ConfigFileFixture(config_file_path)) | 105 | self.useFixture( |
317 | 106 | EnvironmentVariableFixture(CONF_FILE_ENV_VAR, config_file_path)) | ||
318 | 243 | 107 | ||
319 | 244 | 108 | ||
320 | 245 | class LibdepFixture(Fixture): | 109 | class LibdepFixture(Fixture): |
321 | 246 | 110 | ||
322 | === modified file 'devportalbinary/tests/test_database.py' | |||
323 | --- devportalbinary/tests/test_database.py 2012-11-13 14:35:23 +0000 | |||
324 | +++ devportalbinary/tests/test_database.py 2012-11-13 14:35:23 +0000 | |||
325 | @@ -1,112 +1,12 @@ | |||
326 | 1 | import os | ||
327 | 2 | 1 | ||
328 | 3 | from fixtures import TempDir | ||
329 | 4 | from testresources import ResourcedTestCase | ||
330 | 5 | from testtools import TestCase | 2 | from testtools import TestCase |
331 | 6 | from testtools.matchers import ( | ||
332 | 7 | Equals, | ||
333 | 8 | Matcher, | ||
334 | 9 | ) | ||
335 | 10 | 3 | ||
348 | 11 | from devportalbinary.database import ( | 4 | from devportalbinary.database import LibdepServiceClient |
349 | 12 | get_dependency_database, | 5 | from devportalbinary.testing import get_libdep_service_client |
338 | 13 | LibdepServiceClient, | ||
339 | 14 | load_configuration, | ||
340 | 15 | PackageDatabase, | ||
341 | 16 | ) | ||
342 | 17 | from devportalbinary.testing import ( | ||
343 | 18 | ConfigFileFixture, | ||
344 | 19 | ConfigSettings, | ||
345 | 20 | get_libdep_service_client, | ||
346 | 21 | postgres_db_resource, | ||
347 | 22 | ) | ||
350 | 23 | 6 | ||
351 | 24 | from libdep_service_client.client import Client | 7 | from libdep_service_client.client import Client |
352 | 25 | 8 | ||
353 | 26 | 9 | ||
354 | 27 | class ResultsIn(Matcher): | ||
355 | 28 | |||
356 | 29 | def __init__(self, db, rows): | ||
357 | 30 | self._db = db | ||
358 | 31 | self._rows = rows | ||
359 | 32 | |||
360 | 33 | def match(self, query): | ||
361 | 34 | # XXX: Abstraction violation | ||
362 | 35 | results = self._db._store.execute(query) | ||
363 | 36 | return Equals(self._rows).match(list(results)) | ||
364 | 37 | |||
365 | 38 | |||
366 | 39 | class TestDatabase(TestCase, ResourcedTestCase): | ||
367 | 40 | |||
368 | 41 | resources = [ | ||
369 | 42 | ('db_fixture', postgres_db_resource), | ||
370 | 43 | ] | ||
371 | 44 | |||
372 | 45 | def get_package_db(self): | ||
373 | 46 | db = PackageDatabase(self.db_fixture.conn) | ||
374 | 47 | self.addCleanup(db.close) | ||
375 | 48 | return db | ||
376 | 49 | |||
377 | 50 | def test_unknown_library(self): | ||
378 | 51 | db = self.get_package_db() | ||
379 | 52 | deps = db.get_multiple_dependencies(['libfoo.so.0'], 'i386') | ||
380 | 53 | self.assertEqual(deps, {}) | ||
381 | 54 | |||
382 | 55 | def test_close(self): | ||
383 | 56 | # Test that we can close the package db. | ||
384 | 57 | db = PackageDatabase(self.db_fixture.conn) | ||
385 | 58 | db.close() | ||
386 | 59 | |||
387 | 60 | def test_close_twice(self): | ||
388 | 61 | # Test that we can close the package db twice with no exception. | ||
389 | 62 | db = PackageDatabase(self.db_fixture.conn) | ||
390 | 63 | db.close() | ||
391 | 64 | db.close() | ||
392 | 65 | |||
393 | 66 | |||
394 | 67 | class TestDatabaseConfiguration(TestCase): | ||
395 | 68 | |||
396 | 69 | def use_database_config(self, **db_settings): | ||
397 | 70 | return self.useFixture(ConfigSettings(('database', db_settings))) | ||
398 | 71 | |||
399 | 72 | def test_get_db_info_from_config_sqlite(self): | ||
400 | 73 | other_tempdir = self.useFixture(TempDir()) | ||
401 | 74 | expected_db_path = os.path.join(other_tempdir.path, 'db') | ||
402 | 75 | self.use_database_config(db_type='sqlite', path=expected_db_path) | ||
403 | 76 | options = load_configuration() | ||
404 | 77 | self.assertRaises(ValueError, PackageDatabase.get_db_info_from_config, | ||
405 | 78 | options) | ||
406 | 79 | |||
407 | 80 | def test_remote_service(self): | ||
408 | 81 | base_url = 'http://example.com/libdep-service/' | ||
409 | 82 | self.use_database_config(db_type='libdep-service', base_url=base_url) | ||
410 | 83 | db = get_dependency_database() | ||
411 | 84 | self.assertIsInstance(db, LibdepServiceClient) | ||
412 | 85 | self.assertEqual(base_url, db._client.base_url) | ||
413 | 86 | |||
414 | 87 | def test_get_db_info_from_config_postgres(self): | ||
415 | 88 | expected_username = self.getUniqueString() | ||
416 | 89 | expected_password = self.getUniqueString() | ||
417 | 90 | expected_host = self.getUniqueString() | ||
418 | 91 | expected_port = self.getUniqueInteger() | ||
419 | 92 | expected_db_name = self.getUniqueString() | ||
420 | 93 | |||
421 | 94 | self.use_database_config( | ||
422 | 95 | db_type='postgres', | ||
423 | 96 | username=expected_username, | ||
424 | 97 | password=expected_password, | ||
425 | 98 | host=expected_host, | ||
426 | 99 | port=expected_port, | ||
427 | 100 | db_name=expected_db_name) | ||
428 | 101 | options = load_configuration() | ||
429 | 102 | uri = PackageDatabase.get_db_info_from_config(options) | ||
430 | 103 | self.assertEqual(expected_db_name, uri.database) | ||
431 | 104 | self.assertEqual(expected_port, uri.port) | ||
432 | 105 | self.assertEqual(expected_host, uri.host) | ||
433 | 106 | self.assertEqual(expected_password, uri.password) | ||
434 | 107 | self.assertEqual(expected_username, uri.username) | ||
435 | 108 | |||
436 | 109 | |||
437 | 110 | class TestLibdepServiceClient(TestCase): | 10 | class TestLibdepServiceClient(TestCase): |
438 | 111 | 11 | ||
439 | 112 | TEST_DATA = [('libfoo', {'i386': {'libfoo': 'libfoo-bin'}})] | 12 | TEST_DATA = [('libfoo', {'i386': {'libfoo': 'libfoo-bin'}})] |
440 | 113 | 13 | ||
441 | === modified file 'setup.py' | |||
442 | --- setup.py 2012-11-13 14:35:23 +0000 | |||
443 | +++ setup.py 2012-11-13 14:35:23 +0000 | |||
444 | @@ -18,6 +18,8 @@ | |||
445 | 18 | ) | 18 | ) |
446 | 19 | from setuptools import setup, find_packages | 19 | from setuptools import setup, find_packages |
447 | 20 | 20 | ||
448 | 21 | # XXX: Need to do a trawl to see if we are depending on things that we are no | ||
449 | 22 | # longer using. | ||
450 | 21 | 23 | ||
451 | 22 | __version__ = get_version('devportalbinary/__init__.py') | 24 | __version__ = get_version('devportalbinary/__init__.py') |
452 | 23 | 25 |