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
|
# Copyright 2015 OpenStack Foundation
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""
Test fixtures.
.. versionadded:: 1.3
"""
import threading
import fixtures
from oslo_utils import timeutils
from oslo_utils import uuidutils
class TimeFixture(fixtures.Fixture):
"""A fixture for overriding the time returned by timeutils.utcnow().
:param override_time: datetime instance or list thereof. If not given,
defaults to the current UTC time.
"""
def __init__(self, override_time=None):
super(TimeFixture, self).__init__()
self._override_time = override_time
def setUp(self):
super(TimeFixture, self).setUp()
timeutils.set_time_override(self._override_time)
self.addCleanup(timeutils.clear_time_override)
def advance_time_delta(self, timedelta):
"""Advance overridden time using a datetime.timedelta."""
timeutils.advance_time_delta(timedelta)
def advance_time_seconds(self, seconds):
"""Advance overridden time by seconds."""
timeutils.advance_time_seconds(seconds)
class _UUIDSentinels(object):
"""Registry of dynamically created, named, random UUID strings in regular
(with hyphens) and similar to some keystone IDs (without hyphens) formats.
An instance of this class will dynamically generate attributes as they are
referenced, associating a random UUID string with each. Thereafter,
referring to the same attribute will give the same UUID for the life of the
instance. Plan accordingly.
Usage::
from oslo_utils.fixture import uuidsentinel as uuids
from oslo_utils.fixture import keystoneidsentinel as keystids
...
foo = uuids.foo
do_a_thing(foo)
# Referencing the same sentinel again gives the same value
assert foo == uuids.foo
# But a different one will be different
assert foo != uuids.bar
# Same approach is valid for keystoneidsentinel:
data = create_some_data_structure(keystids.bar, var1, var2, var3)
assert extract_bar(data) == keystids.bar
"""
def __init__(self, is_dashed=True):
self._sentinels = {}
self._lock = threading.Lock()
self.is_dashed = is_dashed
def __getattr__(self, name):
if name.startswith('_'):
raise AttributeError('Sentinels must not start with _')
with self._lock:
if name not in self._sentinels:
self._sentinels[name] = uuidutils.generate_uuid(
dashed=self.is_dashed)
return self._sentinels[name]
# Singleton sentinel instance. Caveat emptor: using this multiple times in the
# same process (including across multiple modules) will result in the same
# values
uuidsentinel = _UUIDSentinels()
keystoneidsentinel = _UUIDSentinels(is_dashed=False)
|
