def test_should_fail_if_inputs_do_not_have_the_same_type(self):
     testf = lambda: timestamp.compare(self.TESTS[0][0],
                                       datetime.datetime.utcnow())
     expect(testf).to(raise_error(ValueError))
     testf = lambda: timestamp.compare(self.TESTS[0],
                                       datetime.datetime.utcnow())
     expect(testf).to(raise_error(ValueError))

 def test_should_fail_if_service_is_bad(self):
     testfs = [
         lambda: self._get_registry(),
         lambda: service.MethodRegistry(None),
         lambda: service.MethodRegistry(object()),
     ]
     for f in testfs:
         expect(f).to(raise_error(ValueError))

 def test_should_fail_if_non_money_is_used(self):
     testfs = [
         lambda: money.add(self._SOME_YEN, object()),
         lambda: money.add(object(), self._SOME_USD),
         lambda: money.add(None, self._SOME_USD),
         lambda: money.add(self._SOME_YEN, None),
     ]
     for testf in testfs:
         expect(testf).to(raise_error(ValueError))

 def test_should_fail_for_delta_metrics_with_unmergable_types(self):
     no_init = metric_value.create()
     unmergeables = [
         metric_value.create(stringValue='a test string'),
         metric_value.create(boolValue=False),
     ]
     for mv in unmergeables:
         testf = lambda: metric_value.merge(MetricKind.DELTA, mv, mv)
         expect(testf).to(raise_error(ValueError))

 def test_should_fail_on_dissimilar_bucket_options(self):
     explicit = _make_explicit_dist()
     linear = _make_linear_dist()
     exponential = _make_exponential_dist()
     pairs = (
         (explicit, linear),
         (explicit, exponential),
         (linear, exponential)
     )
     for p in pairs:
         testf = lambda: distribution.merge(*p)
         expect(testf).to(raise_error(ValueError))

 def test_should_fail_if_bad_options_are_used(self):
     should_fail = [
         lambda: caches.create(object()),
     ]
     for testf in should_fail:
         expect(testf).to(raise_error(ValueError))

 def test_constructor_should_fail_on_bad_deques(self):
     testf = lambda: caches.DequeOutTTLCache(_TEST_NUM_ENTRIES, _TEST_TTL,
                                             out_deque=object())
     expect(testf).to(raise_error(ValueError))

 def test_should_fail_on_unallowed_negative_overflows(self):
     testf = lambda: money.add(self._SOME_YEN_DEBT, self._LARGE_YEN_DEBT)
     expect(testf).to(raise_error(OverflowError))

from expects import expect, raise_error
from bankbarcode.bankbarcode import BankBarcode

with description('BankBarcode'):
    with it('doesn\'t have code generation method'):
        error = 'This method is not implemented!'

        def callback():
            return BankBarcode().code()

        expect(callback).to(raise_error(NotImplementedError, error))

    with it('can\'t create barcode without code generation method'):
        path = '/tmp/mybarcode'
        error = 'This method is not implemented!'

        def callback():
            return BankBarcode().save(path)

        expect(callback).to(raise_error(NotImplementedError, error))

    with it('can\'t create SVG without code generation method'):
        error = 'This method is not implemented!'

        def callback():
            return BankBarcode().svg()

        expect(callback).to(raise_error(NotImplementedError, error))

 def test_should_fail_if_req_is_bad(self):
     testf = lambda: self.agg.report(object())
     expect(testf).to(raise_error(ValueError))
     testf = lambda: self.agg.report(None)
     expect(testf).to(raise_error(ValueError))

 def test_should_raise_if_constructed_with_a_bad_error_cause(self):
     testf = lambda: report_request.Info(error_cause=object())
     expect(testf).to(raise_error(ValueError))

 def test_should_fail_when_the_units_and_nanos_are_mismatched(self):
     for m in self._MISMATCHED_UNITS:
         expect(lambda: money.check_valid(m)).to(raise_error(ValueError))

 def test_should_fail_if_no_buckets_are_set(self):
     testf = lambda: distribution.add_sample(_UNDERFLOW_SAMPLE,
                                             self.NOTHING_SET)
     expect(testf).to(raise_error(ValueError))

 def test_should_fail_when_no_currency_is_set(self):
     expect(lambda: money.check_valid(messages.Money())).to(
         raise_error(ValueError))

 def test_should_fail_when_the_currency_is_bad(self):
     expect(lambda: money.check_valid(self._BAD_CURRENCY)).to(
         raise_error(ValueError))

 def test_should_fail_if_not_really_money(self):
     expect(lambda: money.check_valid(object())).to(raise_error(ValueError))
     expect(lambda: money.check_valid(None)).to(raise_error(ValueError))

 def test_should_fail_if_check_request_is_missing(self):
     req = messages.ServicecontrolServicesReportRequest(
         serviceName=self.SERVICE_NAME)
     testf = lambda: self.agg.report(req)
     expect(testf).to(raise_error(ValueError))

 def test_should_fail_if_service_name_does_not_match(self):
     req = _make_test_request(self.SERVICE_NAME + u'-will-not-match')
     testf = lambda: self.agg.report(req)
     expect(testf).to(raise_error(ValueError))

from expects import expect, equal, raise_error
from bankbarcode.cuaderno57 import Recibo507

with description('Recibo507 with due date of cuaderno57'):
    with it('Validate than suffix is less than 500'):
        def callback():
            entity = '01234567'
            suffix = '023'
            ref = '12345678901'
            notice = '123456'
            amount = '6543.21'
            due_date = datetime(2015, 11, 01)
            recibo = Recibo507(entity, suffix, ref, notice, amount, due_date)
        expect(callback).to(
            raise_error(ValueError,
                        'suffix with due date must be bigger than 499'))

    with it('Overwrites introduced notice for due date DDMMAA'):
        entity = '22350466'
        suffix = '501'
        ref = '00000000015'
        notice = '300815'
        amount = '53.98'
        due_date = datetime(2015, 11, 01)
        recibo = Recibo507(entity, suffix, ref, notice, amount, due_date)
        expect(recibo.notice).not_to(equal(notice))
        expect(recibo.notice).to(equal(due_date.strftime('%d%m%y')))

    with it('accomplish the example of cuaderno57 with due date Datetime'):
        entity = '22350466'
        suffix = '501'

 def test_should_fail_on_dissimilar_bucket_counts(self):
     for _, d2, d3 in self.merge_triples:
         testf = lambda: distribution.merge(d2, d3)
         expect(testf).to(raise_error(ValueError))