def test_should_fail_if_actual_has_expected_header_without_value(self):
        with failure(
            self.response,
            "to have header {!r} with value {!r} but was".format(IRRELEVANT_HEADER_KEY1, IRRELEVANT_HEADER_VALUE3),
        ):

            expect(response=self.response).to.have.header(IRRELEVANT_HEADER_KEY1, IRRELEVANT_HEADER_VALUE3)

        def it_should_fail_if_actual_has_key_in_kwargs_but_not_in_args():
            with failure(_.dct, "not to have key 'bar' with value 0 but was 0"):
                expect(_.dct).not_to.have.keys('foo', bar=0)

            def it_should_fail_if_actual_has_key_in_dict_with_value():
                with failure(_.dct, "not to have key 'bar' with value 0 but was 0"):
                    expect(_.dct).not_to.have.keys({'bar': 0, 'foo': 1})

    def test_should_fail_if_actual_has_expected_header_and_value(self):
        with failure(
            self.response,
            "not to have header {!r} with value {!r}".format(IRRELEVANT_HEADER_KEY1, IRRELEVANT_HEADER_VALUE1),
        ):

            expect(response=self.response).not_to.have.header(IRRELEVANT_HEADER_KEY1, IRRELEVANT_HEADER_VALUE1)

    def test_should_fail_if_actual_has_header_without_value_in_kwargs(self):
        with failure(self.response,
                     "to have header 'content-length' with value '25'"):

            expect(response=self.response).to.have.headers(
                content_type=IRRELEVANT_HEADER_VALUE1,
                content_length='25')

        def it_should_fail_if_actual_raises_expected_exception_with_message():
            message = 'Foo error'
            failure_message = 'not to raise AttributeError with message {} but message was {}'.format(
                repr(message), repr(message))

            def callback():
                raise AttributeError(message)

            with failure(callback, failure_message):
                expect(callback).not_to.raise_error(AttributeError, message)

    def it_should_fail_if_actual_raises_but_message_does_not_match_pattern():
        pattern = r'\W+ error'

        def callback():
            raise AttributeError(_.message)

        with failure(callback, "to raise AttributeError with "
                     "message {} but message was {}"
                     .format(repr(pattern), repr(_.message))):

            expect(callback).to.raise_error(AttributeError, pattern)

 def callback():
     with failure(have_length(0)):
         raise AssertionError('foo')

            expect(callback).to(raise_error(AssertionError))

        with it('fails if another exception raised'):
            def callback():
                with failure:
                    raise KeyError()

            expect(callback).to(raise_error(AssertionError))

    with context('with message'):
        with before.each:
            self.message = "to be 'bar'"
            self.pattern = "to be '\w+'"

        with it('passes if assertion raised and message ends with'):
            with failure(self.message):
                raise AssertionError("Expected 'foo' {0}".format(self.message))

        with it('passes if assertion error raised and message matches'):
            with failure(match(self.pattern)):
                raise AssertionError("Expected 'foo' {0}".format(self.message))

        with it('passes if assertion error raised and message has length 0'):
            with failure(have_length(0)):
                raise AssertionError('')

        with it('fails if assertion error not raised'):
            def callback():
                with failure(self.message):
                    pass

# -*- coding: utf-8 -*

from expects import *
from expects.testing import failure


with describe('be_above_or_equal'):
    with it('should pass if number is above expected'):
        expect(5).to(be_above_or_equal(4))

    with it('should pass if number equals expected'):
        expect(5).to(be_above_or_equal(5))

    with it('should fail if number is not above or equal expected'):
        with failure('expected: 1 to be above or equal 4'):
            expect(1).to(be_above_or_equal(4))

    with context('when negated'):
        with it('should pass if number is not above or equal expected'):
            expect(1).not_to(be_above_or_equal(4))

        with it('should fail if number is above expected'):
            with failure('expected: 5 not to be above or equal 4'):
                expect(5).not_to(be_above_or_equal(4))

        with it('should fail if number equals expected'):
            with failure('expected: 5 not to be above or equal 5'):
                expect(5).not_to(be_above_or_equal(5))

    def it_should_fail_if_actual_iterable_does_not_have_the_expected_length():
        actual = iter('foo')

        with failure(actual, 'to have length 2 but was 3'):
            expect(actual).to.have.length(2)

 def it_should_fail_if_actual_is_not_above_expected():
     with failure(1, 'to be above 4'):
         expect(1).to.be.above(4)

 def it_should_fail_if_actual_is_false():
     with failure(False, "to be True"):
         expect(False).to.be.true

# -*- coding: utf-8 -*

from expects import *
from expects.testing import failure


with describe("be_false"):
    with it("should pass if object is false"):
        expect(False).to(be_false)

    with it("should fail if object is true"):
        with failure("Expected True to be false"):
            expect(True).to(be_false)

    with context("#negated"):
        with it("should pass if object is not false"):
            expect(True).not_to(be_false)

        with it("should fail if object is false"):
            with failure("Expected False not to be false"):
                expect(False).not_to(be_false)

from expects.testing import failure


with describe('have_len'):
    with it('passes if string has the expected length'):
        expect('foo').to(have_len(3))

    with it('passes if string has length matching'):
        expect('foo').to(have_len(above_or_equal(3)))

    with it('passes if iterable has the expected length'):
        expect(iter('foo')).to(have_len(3))

    with it('fails if string does not have the expected length'):
        with failure("but: was 3"):
            expect('foo').to(have_len(2))

    with it('fails if string does not have length matching'):
        with failure("but: was 3"):
            expect('foo').to(have_len(below(3)))

    with it('fails if iterable does not have the expected length'):
        with failure("but: was 3"):
            expect(iter('foo')).to(have_len(2))

    with context('when negated'):
        with it('passes if string does not have the expected length'):
            expect('foo').not_to(have_len(2))

        with it('fails if string has the expected length'):

 def it_should_fail_if_actual_has_property_in_kwargs_but_not_in_args():
     with failure(_.obj, "not to have property 'bar' with value 0 but was 0"):
         expect(_.obj).not_to.have.properties('foo', bar=0)

 def it_should_fail_if_actual_has_property_in_dict_with_value():
     with failure(_.obj, "not to have property 'bar' with value 0 but was 0"):
         expect(_.obj).not_to.have.properties({'bar': 0, 'foo': 1})

 def it_should_fail_if_actual_is_true():
     with failure(True, "not to be True"):
         expect(True).not_to.be.true

 def it_should_fail_if_actual_is_above_expected():
     with failure(5, 'not to be above 4'):
         expect(5).not_to.be.above(4)

# -*- coding: utf-8 -*

from expects import *
from expects.testing import failure


with describe('be_below'):
    with it('should pass if number is below expected'):
        expect(1).to(be_below(4))

    with it('should fail if number is not below expected'):
        with failure('expected: 4 to be below 1'):
            expect(4).to(be_below(1))

    with context('#negated'):
        with it('should pass if number is not below expected'):
            expect(4).not_to(be_below(1))

        with it('should fail if number is below expected'):
            with failure('expected: 1 not to be below 4'):
                expect(1).not_to(be_below(4))

        def it_should_fail_if_actual_has_the_expected_length():
            actual = 'foo'

            with failure(actual, 'not to have length 3 but was 3'):
                expect(actual).not_to.have.length(3)