def test_decorator_enabled_decorator_when_feature_not_exist(self):
@self.rollout.enabled('bar')
def foo(name):
return name
with should.throw(RolloutException):
foo('bazz')
def test_missing_dependency(self):
@self.inject
def foo(missing=InjectorErrorsTests):
pass
with should.throw(LookupError):
foo()
def test_missing_dependency(self):
@self.inject
def foo(missing=InjectorErrorsTests):
pass
with should.throw(LookupError):
foo()
def test_decorator_enabled_decorator_when_feature_disabled(self):
@self.rollout.enabled(self.FN)
def foo(name):
return name
self.rollout.disable(self.FN)
with should.throw(RolloutException):
foo('bazz')
def test_patch_hides_previous_deps(self):
@self.inject
def test(foo=InjectorPatchTests): pass
self.inject.patch({})
with should.throw(LookupError):
test()
self.inject.unpatch()
test()
def test_patch_hides_previous_deps(self):
@self.inject
def test(foo=InjectorPatchTests):
pass
self.inject.patch({})
with should.throw(LookupError):
test()
self.inject.unpatch()
test()
def test_raises_exception_if_invalid_coroutine(self):
@coroutine
def to_xxx(destination=None):
while True:
value = yield
value.to_xxx()
register(to_xxx)
pipeline = self.pipeline.to_xxx()
with should.throw(AttributeError):
pipeline()
def test_raises_exception_if_invalid_coroutine(self):
@coroutine
def to_xxx(destination=None):
while True:
value = yield
value.to_xxx()
register(to_xxx)
pipeline = self.pipeline.to_xxx()
with should.throw(AttributeError):
pipeline()
def test_basic(self):
result = 5
result | should.be_integer()
(1 + 1) | should_not.equal(1)
"foo" | should.equal('foo')
len([1, 2, 3]) | should.be_greater_than(2)
result += 0.5
result | should.equal(1 / 2 + 5)
1 | should_not.eq(2)
# Matchers not requiring a param can skip the call parens
True | should.be_truthy
# Check for exceptions with the context manager interface
with should.throw(TypeError):
raise TypeError('foo')
with should.not_raise: # will report a failure
fp = open('does-not-exists.txt')
# Apply our custom logic for a test
'FooBarBaz' | should.pass_callback(lambda x: x[3:6] == 'Bar')
def test_backend_should_not_be_none(self):
rollout = Rollout(None)
with should.throw(TypeError):
rollout.backend
def test_descriptor_no_type_found(self):
Foo.DEPS.clear()
Foo.DEPS[InjectorErrorsTests] = self
with should.throw(LookupError):
foo = Foo()
foo.bar()
def test_name_should_be_a_string(self):
with should.throw(AttributeError):
Feature(1, lambda x: True, '100')
def test_percentage_should_be_a_number(self):
with should.throw(AttributeError):
Feature('foo', lambda x: True, 'bar')
def test_get_functionalities_not_implemented(self):
with should.throw(NotImplementedError):
self.backend.get_functionalities()
def test_name_cannot_be_None(self):
with should.throw(AttributeError):
Feature(None, lambda x: True, '100')
def test_cannot_set_invalid_attributes(self):
f = Feature('foo', lambda x: True, 100)
with should.throw(AttributeError):
f.bar
def test_percentage_should_be_greater_than_0(self):
with should.throw(AttributeError):
Feature('foo', lambda x: True, -1)
def test_percentage_should_be_lower_than_100(self):
with should.throw(AttributeError):
Feature('foo', lambda x: True, 101)
def test_percentage_should_be_a_number(self):
with should.throw(AttributeError):
Feature('foo', lambda x: True, 'bar')
def test_name_is_read_only(self):
f = Feature("foo", lambda x: True, 20)
with should.throw(RuntimeError):
f.name = "bar"
def test_get_functionalities_not_implemented(self):
with should.throw(NotImplementedError):
self.backend.get_functionalities()
def test_missing_dependency_descriptor(self):
egg = Eggs()
with should.throw(LookupError):
egg.missing_descriptor
def test_positional_arg(self):
foo = self.inject(lambda param=unittest.TestCase: None)
with should.throw(TypeError):
foo(self)
def test_descriptor_no_type_found(self):
Foo.DEPS.clear()
Foo.DEPS[InjectorErrorsTests] = self
with should.throw(LookupError):
foo = Foo()
foo.bar()
def test_name_should_be_a_string(self):
with should.throw(AttributeError):
Feature(1, lambda x: True, '100')
def test_percentage_should_be_greater_than_0(self):
with should.throw(AttributeError):
Feature('foo', lambda x: True, -1)
def test_name_is_read_only(self):
f = Feature("foo", lambda x: True, 20)
with should.throw(RuntimeError):
f.name = "bar"
def test_missing_dependency_descriptor(self):
egg = Eggs()
with should.throw(LookupError):
egg.missing_descriptor
def test_percentage_should_be_lower_than_100(self):
with should.throw(AttributeError):
Feature('foo', lambda x: True, 101)
def test_name_cannot_be_None(self):
with should.throw(AttributeError):
Feature(None, lambda x: True, '100')
def test_cannot_set_invalid_attributes(self):
f = Feature('foo', lambda x: True, 100)
with should.throw(AttributeError):
f.bar
def test_unpatch_error(self):
self.inject.patch({})
self.inject.unpatch()
with should.throw(RuntimeError):
self.inject.unpatch()
def test_positional_arg(self):
foo = self.inject(lambda param=unittest.TestCase: None)
with should.throw(TypeError):
foo(self)
def test_using_injector_as_decorator(self):
with should.throw(RuntimeError):
@injector
def foo(): pass
def test_unpatch_error(self):
self.inject.patch({})
self.inject.unpatch()
with should.throw(RuntimeError):
self.inject.unpatch()
def test_set_percentage_to_negative(self):
with should.throw(AttributeError):
self.rollout.set_percentage(self.FN, -1)
def test_proxy_dependency_missing(self):
dm = DependencyMap()
l = dm.proxy("hi")
with should.throw(LookupError):
l.foo()
def test_proxy_dependency_missing(self):
dm = DependencyMap()
l = dm.proxy("hi")
with should.throw(LookupError):
l.foo()
def test_using_injector_as_decorator(self):
with should.throw(RuntimeError):
@injector
def foo():
pass
def pyshould_test_sample():
import unittest
# from pyshould import *
import pyshould.patch
from pyshould import should
result | should.be_integer()
(1 + 1) | should_not.equal(1)
"foo" | should.equal('foo')
len([1, 2, 3]) | should.be_greater_than(2)
result | should.equal(1 / 2 + 5)
1 | should_not.eq(2)
# Matchers not requiring a param can skip the call parens
True | should.be_truthy
# Check for exceptions with the context manager interface
with should.throw(TypeError):
raise TypeError('foo')
with should.not_raise: # will report a failure
fp = open('does-not-exists.txt')
# Apply our custom logic for a test
'FooBarBaz' | should.pass_callback(lambda x: x[3:6] == 'Bar')
should.be_an_integer.or_string.and_equal(1)
# (integer) OR (string AND equal 1)
should.be_an_integer.or_a_float.or_a_string
# (integer) OR (float) OR (string)
should.be_an_integer.or_a_string.and_equal_to(10).or_a_float
# (integer) OR (string AND equal 10) OR (float)
should.be_an_integer.or_a_string.but_less_than(10)
# (integer OR string) AND (less than 10)
# Note: we can use spacing to make them easier to read
should.be_an_integer.or_a_string.and_equal(0).or_a_float
# (integer) OR (string AND equal 0) OR (float)
# Note: in this case we use capitalization to make them more obvious
should.be_an_integer.Or_a_string.And_equal(1).But_Not_be_a_float
# ( (integer) OR (string AND equal 1) ) AND (not float)
# Note: if no matchers are given the last one is used
should.be_equal_to(10).Or(20).Or(30)
# (equal 10) OR (equal 20) OR (equal 30)
# Note: If no combinator is given AND is used by default
should.integer.greater_than(10).less_than(20)
# (integer) AND (greater than 10) AND (less than 20)
# Note: But by using should_either we can set OR as default
should_either.equal(10).equal(20).equal(30)
class TestSequenceFunctions1(unittest.TestCase):
def setUp(self):
self.seq = list(range(10))
def test_shuffle(self):
# make sure the shuffled sequence does not lose any elements
random.shuffle(self.seq)
self.seq.sort()
self.assertEqual(self.seq, list(range(10)))
# should raise an exception for an immutable sequence
self.assertRaises(TypeError, random.shuffle, (1, 2, 3))
def test_choice(self):
element = random.choice(self.seq)
a = 10
a | should.gt(20)
def test_sample(self):
with self.assertRaises(ValueError):
random.sample(self.seq, 20)
for element in random.sample(self.seq, 5):
self.assertTrue(element in self.seq)
unittest.main()
