def test_inheritance_types():
d = {
'a': 1,
'b': '2',
'c': True,
}
o = OpenStructChild2(a=d,
b=OpenStruct(d),
c=OpenStructChild2(d),
d=OpenStructChild1(d),
e=OpenStructChild2(OpenStructChild1(d)))
o.n.o = 1
o.p = d
o.q = OpenStruct(d)
o.r = OpenStructChild2(d)
o.s = OpenStructChild1(d)
o.t = OpenStructChild2(OpenStructChild1(d))
assert isinstance(o, OpenStructChild2)
assert isinstance(o.a, dict)
assert not isinstance(o.b, OpenStructChild2)
assert isinstance(o.c, OpenStructChild2)
assert isinstance(o.d, OpenStructChild1)
assert isinstance(o.e, OpenStructChild2)
assert isinstance(o.n, OpenStructChild2)
assert isinstance(o.n.o, int)
assert isinstance(o.p, dict)
assert not isinstance(o.q, OpenStructChild2)
assert isinstance(o.r, OpenStructChild2)
assert isinstance(o.s, OpenStructChild1)
assert isinstance(o.t, OpenStructChild2)
def test_process_tasks_src_only(monkeypatch, mock_provisioner):
"""
In this scenario _run has to call mktemp on remote system to come up with a suitable temporary file to use
"""
src = '/some/local/file'
monkeypatch.setattr(os.path, 'isfile', lambda x: True)
def side_effect(x, warn_only=None):
if x == 'mktemp':
return '/tmp/whatever'
return True
monkeypatch.setattr(fabric.operations, 'run',
Mock(side_effect=side_effect))
job1 = OpenStruct(src=src)
task1 = OpenStruct(run=[job1.__dict__])
list_of_tasks = [task1]
mock_provisioner.process_tasks(list_of_tasks)
expected_run_calls = [
call('mktemp'),
call('mkdir -p {0}'.format('/tmp')),
call('{0}'.format('/tmp/whatever')),
]
expected_put_calls = [
call(src, '/tmp/whatever', mode=0500, use_sudo=False),
]
def test_inheritance_types():
class TestOpenStruct(OpenStruct):
pass
class AnotherOpenStruct(OpenStruct):
pass
d = {'a': 1, 'b': 2, 'c': 3}
o = TestOpenStruct(a=d,
b=OpenStruct(d),
c=TestOpenStruct(d),
d=AnotherOpenStruct(d),
e=TestOpenStruct(AnotherOpenStruct(d)))
o.n.o = 1
o.p = d
o.q = OpenStruct(d)
o.r = TestOpenStruct(d)
o.s = AnotherOpenStruct(d)
o.t = TestOpenStruct(AnotherOpenStruct(d))
assert isinstance(o, TestOpenStruct)
assert isinstance(o.a, dict)
assert not isinstance(o.b, TestOpenStruct)
assert isinstance(o.c, TestOpenStruct)
assert isinstance(o.d, AnotherOpenStruct)
assert isinstance(o.e, TestOpenStruct)
assert isinstance(o.n, TestOpenStruct)
assert isinstance(o.n.o, int)
assert isinstance(o.p, dict)
assert not isinstance(o.q, TestOpenStruct)
assert isinstance(o.r, TestOpenStruct)
assert isinstance(o.s, AnotherOpenStruct)
assert isinstance(o.t, TestOpenStruct)
def test_comparisons():
o1 = OpenStruct()
o1.a.b.c = 10
assert (o1 == 10) is False
assert (o1 is True) is False
o2 = OpenStruct()
o2.a.b.c = 10
assert (o1 == o2) is True
assert (o1 != o2) is False
assert (o1 is o2) is False
assert (o2 is o1) is False
with pytest.raises(TypeError):
o1 > o2
with pytest.raises(TypeError):
o1 < o2
with pytest.raises(TypeError):
o1 >= o2
with pytest.raises(TypeError):
o1 <= o2
def wrap_relations(self, obj, many=False):
obj.status_obj = OpenStruct()
obj.status_obj.id = obj.status
obj.status_obj.name = inverted(User.STATUSES)[obj.status]
obj.role_obj = OpenStruct()
obj.role_obj.id = obj.role
obj.role_obj.name = inverted(User.ROLES)[obj.role]
def test_process_tasks_single_no_sudo_inline(mock_provisioner):
job1 = OpenStruct(body='whoami', sudo=False)
task1 = OpenStruct(run=[job1])
list_of_tasks = [task1]
mock_provisioner.process_tasks(list_of_tasks)
expected_calls = [call('whoami')]
assert fabric.operations.run.mock_calls == expected_calls
def test_keys():
o = OpenStruct()
assert len(o.keys()) == 0
o = OpenStruct(a=1, b=2, c=4)
assert sorted(o.keys()) == sorted([
'a',
'b',
'c',
])
def test_set_get_item():
o = OpenStruct()
o['a'] = 10
assert o['a'] == 10
assert o.a == 10
o = OpenStruct()
o['a']['b']['c'] = 10
assert o['a']['b']['c'] == 10
assert o['a']['b'] == {'c': 10}
assert o['a'] == {'b': {'c': 10}}
assert o == {'a': {'b': {'c': 10}}}
def test_constructor_clone():
o = OpenStruct(a=1, b=2, c=4)
assert o == {'a': 1, 'b': 2, 'c': 4}
a = OpenStruct(o)
assert o == a
b = OpenStruct(o.__dict__)
assert o == b
c = OpenStruct(**(o.__dict__))
assert o == c
d = OpenStruct(**o)
assert o == d
def test_types():
d = {'a': 1, 'b': 2, 'c': 3}
o = OpenStruct(a=d, b=OpenStruct(d))
o.n.o = 1
o.p = d
o.q = OpenStruct(d)
assert isinstance(o, OpenStruct)
assert isinstance(o.a, dict)
assert isinstance(o.b, OpenStruct)
assert isinstance(o.n, OpenStruct)
assert isinstance(o.n.o, int)
assert isinstance(o.p, dict)
assert isinstance(o.q, OpenStruct)
def get_dependencies(self):
"""
Detect commit dependency tree, and return a tuple of dicts mapping
this in both directions. Note that the dependency tree goes in
the reverse direction to the git commit graph, in that the leaves
of the dependency tree are the oldest commits, because newer
commits depend on older commits
:return: (dependencies_from, dependencies_on)
"""
detector_args = OpenStruct({
'recurse': True,
'exclude_commits': [self.base],
'debug': self.debug,
'context_lines': self.context_lines,
})
detector = DependencyDetector(detector_args, self.repo)
listener = ExplodeDependencyListener({})
detector.add_listener(listener)
revs = GitUtils.rev_list("%s..%s" % (self.base, self.head))
for rev in revs:
try:
detector.find_dependencies(rev)
except KeyboardInterrupt:
pass
return (detector.commits, listener.dependencies_from(),
listener.dependencies_on())
def test_iter():
keys = []
o = OpenStruct(a=1, b=2, c=4, d=8)
for key in o:
keys.append(key)
assert sorted(keys) == sorted(['a', 'b', 'c', 'd'])
def test_booleans():
o = OpenStruct(true=True, false=False)
assert o.true is True
assert o.false is False
assert o['true'] is True
assert o['false'] is False
assert isinstance(o.none, OpenStruct)
def test_items():
s = 0
o = OpenStruct(a=1, b=2, c=4, d=8)
for key, value in o.items():
s += value
assert s == 15
def create_critic(self, alpha, hidden_layers):
params = {
'input_shape': self.env.observation_space.shape,
'output_shape': self.env.action_space.shape,
'hidden_layers': hidden_layers
}
self.critic = OpenStruct()
self.critic.online = Critic("{}.critic.online".format(self.name), **params)
self.critic.target = Critic("{}.critic.target".format(self.name), **params)
def create_actor(self, alpha, hidden_layers):
params = {
'input_shape': self.env.observation_space.shape,
'output_shape': self.env.action_space.shape,
'hidden_layers': hidden_layers
}
self.actor = OpenStruct()
self.actor.online = Actor("{}.actor.online".format(self.name), **params)
self.actor.target = Actor("{}.actor.target".format(self.name), **params)
def test_nested_struct():
o = OpenStruct()
o.a.b.c.d = 10
assert o.a.b.c.d == 10
assert o.a.b.c == {'d': 10}
assert o.a.b == {'c': {'d': 10}}
assert o.a == {'b': {'c': {'d': 10}}}
assert o == {'a': {'b': {'c': {'d': 10}}}}
def test_delete_item():
o = OpenStruct(a=1, b=2, c=4)
del o['b']
assert o == {'a': 1, 'c': 4}
o.b.d.e = 10
del o['b']['d']
assert o == {'a': 1, 'c': 4, 'b': {}}
def test_process_tasks_src_dest_cwd(monkeypatch, mock_provisioner):
src = '/some/local/file'
args = 'foo --bar=True --baz'
dest = '/some/remote/file'
cwd = '/some/other/remote/folder'
monkeypatch.setattr(os.path, 'isfile', lambda x: True)
job1 = OpenStruct(src=src, args=args, dest=dest, cwd=cwd)
task1 = OpenStruct(run=[job1.__dict__])
list_of_tasks = [task1]
mock_provisioner.process_tasks(list_of_tasks)
expected_run_calls = [
call('mkdir -p {0}'.format('/some/remote')),
call('cd {0}; {1} {2}'.format(cwd, dest, args)),
]
expected_put_calls = [call(src, dest, mode=0500, use_sudo=False)]
class UserStatusSchema(Schema):
DEFAULT_OBJ = OpenStruct(id=User.STATUSES['active'], name='active')
id = fields.Integer(many=False,
required=False,
allow_none=True,
default=DEFAULT_OBJ.id,
missing=DEFAULT_OBJ.id,
validate=[validate.OneOf(User.STATUSES.values())])
name = fields.String(required=False,
allow_none=True,
default=DEFAULT_OBJ.name,
missing=DEFAULT_OBJ.name)
def test_types_with_dict_convert():
d = {
'a': 1,
'b': '2',
'c': True,
}
o = OpenStruct(dict_convert=True, d=d)
assert isinstance(o, OpenStruct)
assert isinstance(o.d, OpenStruct)
assert isinstance(o.d.a, int)
assert isinstance(o.d.b, str)
assert isinstance(o.d.c, bool)
def test_delete_attr():
o = OpenStruct(a=1, b=2, c=4)
del o.b
assert o == {'a': 1, 'c': 4}
o.b.d.e = 10
del o.b.d
assert o == {'a': 1, 'c': 4, 'b': {}}
del o
with pytest.raises(NameError):
assert o # NoQA
def home():
data = OpenStruct(status=iccp.status)
return (template(
"""
<h1>Status</h1>
<li>{{status}}</li>
<h1>Tools</h1>
<ul>
<li><a href="/set_v?v=2.5">Set electrode voltage to 2.5V </a> (or whatever you want, by editing the URL).</li>
<li><a href="/set_dc?dc=50">Force duty cycle to 50%</a> (or whatever you want), turn of control loop until new electrode voltage is set.</a></li>
<li><a href="/start_calibration">Start Calibration - Measure voltage as a function of duty cycle.</a></li>
<li><a href="/v_for_dc_regression_plot">Show Calibration Results (Regression plot).</a></li>
</ul>
""", data))
def test_empty_struct():
o = OpenStruct()
assert o == {}
assert isinstance(o, OpenStruct)
assert isinstance(o.__dict__, dict)
if o:
assert False
else:
assert True
if not o:
assert True
else:
assert False
def test_shallow_struct():
o = OpenStruct()
o.a = 10
assert o.a == 10
assert o.nonexistent_attribute is not None
if o:
assert True
else:
assert False
if not o:
assert False
else:
assert True
def home():
status = "Commanded voltage is {:.3f}V. Current measured voltage is {:.3f}V. Current is {:.3f}A. Implies a resistive load of {:.3f} Ohms. dc was {:.2f}%"
data = OpenStruct(status=status.format(ippc.cv_voltage, ippc.ms_voltage,
ippc.ms_current, ippc.ms_voltage /
ippc.ms_current, ippc.cv_dc))
return (template(
"""
<h1>{{status}}</h1>
<h1>Tools</h1>
<ul>
<li>
</li>
<li>
<a href="/time_series?v=2.5">Set voltage to 2.5V</a>
</li>
</ul>
""", data))
def test_inheritance_types_with_dict_convert():
d = {
'a': 1,
'b': '2',
'c': True,
}
o = OpenStructChild2(dict_convert=True,
a=OpenStructChild1(d),
b=OpenStruct(d),
c=OpenStructChild2(d),
d=d,
e=OpenStructChild2(OpenStructChild1(d)))
assert isinstance(o, OpenStructChild2)
assert isinstance(o.a, OpenStructChild1)
assert isinstance(o.b, OpenStruct)
assert isinstance(o.c, OpenStructChild2)
assert isinstance(o.d, OpenStructChild2)
assert isinstance(o.e, OpenStructChild2)
assert isinstance(o.d.a, int)
assert isinstance(o.d.b, str)
assert isinstance(o.d.c, bool)
def test_len(value, expected):
o = OpenStruct(value)
assert len(o) == expected
def test__repr(kwargs, expected, expected2):
o = OpenStruct(**kwargs)
assert str(o) == expected or str(o) == expected2
def test_constructor_bad_args(value):
with pytest.raises(TypeError):
OpenStruct(value)
