Ejemplo n.º 1
0
        def should_call_only_with_arguments_that_the_handler_understands():
            call_args = {"evil_extra": None}
            call_args.update(_.handler_kwargs)

            call_result = _.command.call(**call_args)

            expect(call_result).to.be.equal(_.called)
Ejemplo n.º 2
0
 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))
Ejemplo n.º 3
0
            def it_should_pass_if_actual_raises_expected_exception_with_message():
                message = 'Foo error'

                def callback():
                    raise AttributeError(message)

                expect(callback).to.raise_error(AttributeError, message)
Ejemplo n.º 4
0
    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')
Ejemplo n.º 5
0
    def test_request_extraction_with_aggregation(self):
        req = _make_test_request(self.SERVICE_NAME, self.FAKE_OPERATION_ID)
        req = req.allocateQuotaRequest
        req.allocateOperation.quotaMetrics = [
            sc_messages.MetricValueSet(
                metricName=u'a_float',
                metricValues=[
                    metric_value.create(
                        labels={
                            u'key1': u'value1',
                            u'key2': u'value2'},
                        int64Value=12,
                    ),
                ]
            )
        ]

        resp = sc_messages.AllocateQuotaResponse(
            operationId=self.FAKE_OPERATION_ID)
        item = quota_request.CachedItem(req, resp, self.SERVICE_NAME, None)
        expect(item._op_aggregator).to(be_none)
        item.aggregate(req)
        item.aggregate(req)

        extracted = item.extract_request()
        op = extracted.allocateQuotaRequest.allocateOperation
        expect(op.quotaMetrics[0].metricValues[0].int64Value).to(equal(24))
Ejemplo n.º 6
0
    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_not_send_the_request_if_cached(self, dummy_thread_class):
     t = self._mock_transport
     self._subject.start()
     dummy_request = _make_dummy_report_request(self.PROJECT_ID,
                                                self.SERVICE_NAME)
     self._subject.report(dummy_request)
     expect(t.services.report.called).to(be_false)
Ejemplo n.º 8
0
 def it_should_return_the_correct_list_of_available_paths_equal_to_4_size(self):
     expected_paths = [
         [self.vertexA, self.vertexB, self.vertexC, self.vertexD]
     ]
     expect(self.paths_equal_4_size).to(have_len(1))
     for path in expected_paths:
         expect(self.paths_equal_4_size).to(contain(path))
 def test_should_clear_requests_on_stop(self, dummy_thread_class):
     # stop the subject, the transport did not see a request
     self._subject.start()
     self._subject.report(
         _make_dummy_report_request(self.PROJECT_ID, self.SERVICE_NAME))
     self._subject.stop()
     expect(self._mock_transport.services.report.called).to(be_true)
 def test_should_ignore_bad_transport_when_not_cached(self, dummy_thread_class):
     self._subject.start()
     self._subject.report(
         _make_dummy_report_request(self.PROJECT_ID, self.SERVICE_NAME))
     self._mock_transport.services.report.side_effect = lambda: old_div(1,0)
     self._subject.stop()
     expect(self._mock_transport.services.report.called).to(be_true)
Ejemplo n.º 11
0
    def test_when_model_validate_raises_validation_error_then_raises_validation_error(self):
        class InvalidUser(User):
            def validate(self):
                raise errors.ValidationError()

        expect(lambda: self.validator(InvalidUser())).to.raise_error(
            errors.ValidationError)
Ejemplo n.º 12
0
        def should_copy_the_songs_to_the_destination_directory():
            execution = _.env.run(*_.cmd + ['--dest', 'pulled', 'pull'])

            copied_songs = [path for path in execution.files_created
                            if 'pulled' in path and path.endswith('.mp3')]

            expect(copied_songs).to.have.length(2)
Ejemplo n.º 13
0
 def test_should_convert_correctly_with_nanos(self):
     for t in self.NANO_TESTS:
         dt, nanos = timestamp.from_rfc3339(t[0], with_nanos=True)
         expect(dt).to(equal(t[1][0]))
         epsilon = abs(nanos - t[1][1])
         # expect(epsilon).to(equal(0))
         expect(epsilon).to(be_below_or_equal(self.TOLERANCE))
Ejemplo n.º 14
0
        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})
Ejemplo n.º 15
0
 def test_should_merge_bucket_counts_correctly(self):
     for d1, d2, _ in self.merge_triples:
         d1_start = list(d1.bucketCounts)
         d2_start = list(d2.bucketCounts)
         want = [x + y for (x,y) in zip(d1_start, d2_start)]
         distribution.merge(d1, d2)
         expect(d2.bucketCounts).to(equal(want))
Ejemplo n.º 16
0
 def test_should_send_requests_with_default_query_param_api_key(self):
     for default_key in (u'key', u'api_key'):
         wrappee = _DummyWsgiApp()
         control_client = mock.MagicMock(spec=client.Client)
         given = {
             u'wsgi.url_scheme': u'http',
             u'QUERY_STRING': u'%s=my-default-api-key-value' % (default_key,),
             u'PATH_INFO': u'/uvw/method_needs_api_key/with_query_param',
             u'REMOTE_ADDR': u'192.168.0.3',
             u'HTTP_HOST': u'localhost',
             u'HTTP_REFERER': u'example.myreferer.com',
             u'REQUEST_METHOD': u'GET'}
         dummy_response = sc_messages.CheckResponse(
             operationId=u'fake_operation_id')
         wrapped = wsgi.add_all(wrappee,
                                self.PROJECT_ID,
                                control_client,
                                loader=service.Loaders.ENVIRONMENT)
         control_client.check.return_value = dummy_response
         wrapped(given, _dummy_start_response)
         expect(control_client.check.called).to(be_true)
         check_request = control_client.check.call_args_list[0].checkRequest
         check_req = control_client.check.call_args[0][0]
         expect(check_req.checkRequest.operation.consumerId).to(
             equal(u'api_key:my-default-api-key-value'))
         expect(control_client.report.called).to(be_true)
         report_req = control_client.report.call_args[0][0]
         expect(report_req.reportRequest.operations[0].consumerId).to(
             equal(u'api_key:my-default-api-key-value'))
         expect(control_client.allocate_quota.called).to(be_false)
Ejemplo n.º 17
0
    def test_when_callable_raises_type_error_then_should_not_be_catched(self):
        def callback():
            raise TypeError('foo')

        User.name.default = callback

        expect(lambda: User().name).to.raise_error(TypeError, 'foo')
Ejemplo n.º 18
0
    def test_valid_json_object_as_file(self):
        _file = StringIO()
        _file.write(self.user_meta.to_json())
        _file.seek(0)

        actual = serialize.deserialize(_file)
        expect(actual).to.equal([self.user_meta])
Ejemplo n.º 19
0
    def test_when_default_is_callable_then_use_its_returned_value_as_field_default(self):
        default = 'anonymous'
        User.name.default = lambda: default

        user = User()

        expect(user.name).to.be(default)
Ejemplo n.º 20
0
 def test_should_return_none_initially_as_req_is_not_cached(self):
     req = _make_test_request(self.SERVICE_NAME, self.FAKE_OPERATION_ID)
     fake_response = sc_messages.AllocateQuotaResponse(
         operationId=self.FAKE_OPERATION_ID)
     agg = self.agg
     actual = agg.allocate_quota(req)
     expect(actual).to(equal(fake_response))
Ejemplo n.º 21
0
def test_set_blocking_returns_previous_state():
    with tempfile.TemporaryFile() as f:
        io.set_blocking(f, True)
        expect(io.set_blocking(f, False)).to.be.true

        io.set_blocking(f, False)
        expect(io.set_blocking(f, True)).to.be.false
Ejemplo n.º 22
0
    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)
Ejemplo n.º 23
0
 def test_flush_pipes_data_between_streams(self):
     a = StringIO(u'food')
     b = StringIO()
     pump = io.Pump(a, b)
     pump.flush(3)
     expect(a.read(1)).to.equal('d')
     expect(b.getvalue()).to.equal('foo')
 def test_should_send_report_request_if_check_fails(self):
     wrappee = _DummyWsgiApp()
     control_client = mock.MagicMock(spec=client.Client)
     given = {
         u'wsgi.url_scheme': u'http',
         u'PATH_INFO': u'/any/method',
         u'REMOTE_ADDR': u'192.168.0.3',
         u'HTTP_HOST': u'localhost',
         u'HTTP_REFERER': u'example.myreferer.com',
         u'REQUEST_METHOD': u'GET'}
     dummy_response = messages.CheckResponse(
         operationId = u'fake_operation_id',
         checkErrors = [
             messages.CheckError(
                 code=messages.CheckError.CodeValueValuesEnum.PROJECT_DELETED)
         ]
     )
     wrapped = wsgi.add_all(wrappee,
                            self.PROJECT_ID,
                            control_client,
                            loader=service.Loaders.SIMPLE)
     control_client.check.return_value = dummy_response
     wrapped(given, _dummy_start_response)
     expect(control_client.check.called).to(be_true)
     expect(control_client.report.called).to(be_true)
Ejemplo n.º 25
0
 def test_should_load_service_ok(self):
     loaded = service.Loaders.SIMPLE.load()
     registry = service.MethodRegistry(loaded)
     info = registry.lookup(u'GET', u'/anything')
     expect(info).not_to(be_none)
     info = registry.lookup(u'POST', u'/anything')
     expect(info).not_to(be_none)
Ejemplo n.º 26
0
 def test_should_add_matching_hashes_for_matching_labels(self):
     a_dict = {'test': 'dict'}
     mv1 = metric_value.create(labels=a_dict)
     mv2 = metric_value.create(labels=a_dict)
     want = self.make_hash(mv1)
     got = self.make_hash(mv2)
     expect(got).to(equal(want))
Ejemplo n.º 27
0
    def it_should_pass_if_actual_raises_and_message_matches_pattern():
        pattern = r'\w+ error'

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

        expect(callback).to.raise_error(AttributeError, pattern)
Ejemplo n.º 28
0
def assert_messages_and_user(context, numero, usuario):
    count = int(numero)
    #context.thread['msgs'].should.have.length_of(count)
    expect(context.thread['msgs']).to.have.length(count)
    msg = context.thread['msgs'][0]
    #msg['user'].should.equal(usuario)
    expect(msg['user']).to.equal(usuario)
Ejemplo n.º 29
0
        def it_should_contain_extra_messages_if_assertion_fails():
            try:
                _.obj.be(False, 'more', 'extra')
            except AssertionError:
                pass

            expect(_.obj._message).to.equal(['be', 'more', 'extra'])
Ejemplo n.º 30
0
    def test_when_override_mixin_field_then_validates_subclass_field(self):
        class User(UserMixin, models.Model):
            name = fields.String(required=True)

        user = User()

        expect(lambda: user.validate()).to.raise_error(
            errors.ValidationError, 'required')
Ejemplo n.º 31
0
 def test_rejects_list(self):
     name = self.add_module(values={"menu": ["spam", "eggs", "sausage"]})
     expect(partial(config_for_module, name)).to(complain(TypeError))
Ejemplo n.º 32
0
 def test_fileno_delegates_to_stream(self):
     demuxer = io.Demuxer(sys.stdout)
     expect(demuxer.fileno()).to.equal(sys.stdout.fileno())
Ejemplo n.º 33
0
 def check_disables_redirect(self, method):
     client = HttpClient()
     client.enable_cookies()
     getattr(client, method)("http://something")
     expect(self.send_spy["allow_redirects"]).to(be(False))
Ejemplo n.º 34
0
 def test_write_delegates_to_stream(self):
     s = StringIO()
     demuxer = io.Demuxer(s)
     demuxer.write(u'test')
     expect(s.getvalue()).to.equal('test')
Ejemplo n.º 35
0
 def test_reading_partial_chunk(self):
     demuxer = io.Demuxer(self.create_fixture())
     expect(demuxer.read(2)).to.equal('fo')
Ejemplo n.º 36
0
 def test_read_from_socket(self):
     a, b = socket.socketpair()
     a.send('test')
     stream = io.Stream(b)
     expect(stream.read(32)).to.equal('test')
Ejemplo n.º 37
0
 def test_flush_returns_length_written(self):
     a = StringIO(u'fo')
     b = StringIO()
     pump = io.Pump(a, b)
     expect(pump.flush(3)).to.equal(2)
Ejemplo n.º 38
0
 def test_find_if_default_none_and_func_not_none(self):
     e = List([1, 2, 3, 4, 5])
     act = e.find(lambda x: x % 2 == 0)
     expect(act).to(equal(2))
Ejemplo n.º 39
0
###

from expects import expect, equal

AN_EMPTY_STRING = ''
NUMBER_WITH_NONE = '"","5"'
TWO_NUMBERS = '"1","2"'

with description('Given numbers as string'):
    with description('returns the sum of the numbers separated by comma'):
        with it('given an empty string returns 0 in string format'):

            result = string_calculator(AN_EMPTY_STRING)
            expected_result = '0'
            expect(result).to(equal(expected_result))

    with description('given none and a number separated by commma'):
        with it('None equals to 0 and give the sum'):

            result = string_calculator(NUMBER_WITH_NONE)
            expected_result = '5'
            expect(result).to(equal(expected_result))

    with description('given two int numbers separated by comma'):
        with it('it return the sum of both numbers'):

            result = string_calculator(TWO_NUMBERS)
            expected_result = '3'
            expect(result).to(equal(expected_result))
Ejemplo n.º 40
0
 def test_find_if_default_applied_func_results_no_match(self):
     e = List([1, 2, 3, 4, 5])
     act = e.find(default=100, callback=lambda x: x == 0)
     expect(act).to(equal(100))
Ejemplo n.º 41
0
 def test_find_if_func_is_different_raises_error(self):
     e = List([1, 2, 3, 4, 5])
     expect(lambda: e.find(default=0, callback='...')).to(
         raise_error(TypeError))
Ejemplo n.º 42
0
 def test_find_if_default_and_func_not_none(self):
     e = List([1, 2, 3, 4, 5])
     act = e.find(default=100, callback=lambda x: x == 0)
     expect(act).to(equal(100))
Ejemplo n.º 43
0
from sdcclient.secure import PolicyEventsClientV1
from specs import be_successful_api_call

with description("Policy Events v1", "integration") as self:
    with before.each:
        self.client = PolicyEventsClientV1(sdc_url=os.getenv(
            "SDC_SECURE_URL", "https://secure.sysdig.com"),
                                           token=os.getenv("SDC_SECURE_TOKEN"))
    with context("when we try to retrieve policy events from the last 7 days"):
        with it("returns the list of all events happened"):
            week_in_seconds = 7 * 24 * 60 * 60

            ok, res = self.client.get_policy_events_duration(week_in_seconds)

            expect((ok, res)).to(be_successful_api_call)
            expect(res).to(have_keys("ctx", "data"))
            expect(res["data"]).to(
                contain(
                    have_keys("id", "timestamp", "customerId", "source",
                              "name", "description", "cursor")))

        with it("returns the list of all events from a range"):
            to_sec = int(
                (datetime.datetime.utcnow() -
                 datetime.datetime.utcfromtimestamp(0)).total_seconds())
            from_sec = to_sec - (7 * 24 * 60 * 60)

            ok, res = self.client.get_policy_events_range(from_sec, to_sec)

            expect((ok, res)).to(be_successful_api_call)
"""
Suite for Breeds list endpoint calls
"""
import json
from expects import expect, equal
from questions_three.scaffolds.check_script import check, check_suite
from questions_three.http_client import HttpClient

with check_suite('/breeds/*/list* - lists endpoint calls'):

    response = HttpClient().get('https://dog.ceo/api/breeds/list/all')
    with check('response status is 200'):
        expect(response.status_code).to(equal(200))

    body = json.loads(response.text)

    with check('response body status is a success'):
        expect(body["status"]).to(equal('success'))

    with check('response body message to have 94 breeds'):
        expect(len(body["message"])).to(equal(94))

with check_suite('/breeds/list/all/random/* - lists 10 random breeds including sub breeds'):

    response = HttpClient().get('https://dog.ceo/api/breeds/list/all/random/10')
    with check('response status is 200'):
        expect(response.status_code).to(equal(200))

    body = json.loads(response.text)

    with check('response body status is a success'):
Ejemplo n.º 45
0
 def test_read_from_file(self):
     with tempfile.TemporaryFile() as f:
         stream = io.Stream(f)
         f.write('test')
         f.seek(0)
         expect(stream.read(32)).to.equal('test')
Ejemplo n.º 46
0
        "name": "Basic copy",
        "crowdanki_uuid": "6a69bc9d-de6d-42b3-9ba3-9f6e9cc09179",
    }
]

@dataclass
class Models:
    """Mock Anki's models, without initialising Anki's backend."""
    models: dict

Models.all = lambda self: self.models
Models.save = MagicMock()

with description("disambiguate_note_model_uuids"):
    with it("should disambiguate duplicated note model uuids"):
        collection = MagicMock()
        notifier = MagicMock()
        collection.models = Models(deepcopy(MODELS_WITH_DUPLICATES))
        disambiguate_note_model_uuids(collection, notifier)

        expect(collection.models.all()).not_to(equal(MODELS_WITH_DUPLICATES))
        expect(collection.models.all()[0]).to(equal(MODELS_WITH_DUPLICATES[0]))

    with it("should keep note models without duplicates unchanged uuids"):
        collection = MagicMock()
        notifier = MagicMock()
        collection.models = Models(deepcopy(MODELS_WITHOUT_DUPLICATES))
        disambiguate_note_model_uuids(collection, notifier)

        expect(collection.models.all()).to(equal(MODELS_WITHOUT_DUPLICATES))
Ejemplo n.º 47
0
 def test_write_to_socket(self):
     a, b = socket.socketpair()
     stream = io.Stream(a)
     stream.write('test')
     expect(b.recv(32)).to.equal('test')
from mamba import before, describe, it
from expects import contain, equal, expect, have_length

from src.datasource.covid19 import Covid19

with describe("Covid19") as self:

    with before.each:
        self.covid19 = Covid19()

    with describe("#countries") as self:

        with it("returns all country names"):
            expect(self.covid19.countries()).to(contain('Italy', 'Germany'))

    with describe("#metrics") as self:

        with it("returns three metrics for every country"):
            expect(self.covid19.metrics()).to(
                contain(
                    'Italy:confirmed',
                    'Italy:deaths',
                    'Italy:recovered',
                    'Germany:confirmed',
                    'Germany:deaths',
                    'Germany:recovered',
                ))

    with describe("#timeseries") as self:
        with it("returns 58 datapoints for group 'confirmed'"):
            expect(
Ejemplo n.º 49
0
 def test_fileno_delegates_to_file_descriptor(self):
     stream = io.Stream(sys.stdout)
     expect(stream.fileno()).to.equal(sys.stdout.fileno())
Ejemplo n.º 50
0
from specs import be_successful_api_call

with description("Events v1", "integration") as self:
    with before.all:
        self.client = EventsClientV1(sdc_url=os.getenv(
            "SDC_MONITOR_URL", "https://app.sysdigcloud.com"),
                                     token=os.getenv("SDC_MONITOR_TOKEN"))
        self.event_name = "event_v1_test_ci"

    with it("is able to create a custom event"):
        call = self.client.post_event(
            name=self.event_name,
            description=
            "This event was created in a CI pipeline for the Python SDK library"
        )
        expect(call).to(be_successful_api_call)

    with it("is able to list the events happened without any filter"):
        time.sleep(3)  # Wait for the event to appear in the feed
        ok, res = self.client.get_events()
        expect((ok, res)).to(be_successful_api_call)
        expect(res).to(have_key("events"))

    with it("is able to list the events created by the tests"):
        time.sleep(3)  # Wait for the event to appear in the feed
        ok, res = self.client.get_events(last_s=60)
        expect((ok, res)).to(be_successful_api_call)
        expect(res).to(
            have_key("events", contain(have_keys(name=self.event_name))))

    with it("is able to remove the event from the feed"):
Ejemplo n.º 51
0
 def test_fileno_delegates_to_from_stream(self):
     pump = io.Pump(sys.stdout, sys.stderr)
     expect(pump.fileno()).to.equal(sys.stdout.fileno())
Ejemplo n.º 52
0
from mamba import description, context, it
from expects import expect, equal

import regex_project_type
import constants


with description('Regex Project Generator'):
    with context('regex for python'):
        with it('returns it'):
            python_project = regex_project_type.RegexProjectGenerator(['python'])

            expect(python_project.regex()).to(equal([constants.PYTHON_REGEX]))

    with context('having several project types'):
        with it('returns a list'):
            several_projects = regex_project_type.RegexProjectGenerator(['python','go'])

            expect(several_projects.regex()).to(equal([constants.PYTHON_REGEX, constants.GO_REGEX]))
Ejemplo n.º 53
0
 def test_reading_overlapping_chunks(self):
     demuxer = io.Demuxer(self.create_fixture())
     expect(demuxer.read(2)).to.equal('fo')
     expect(demuxer.read(2)).to.equal('o')
     expect(demuxer.read(2)).to.equal('d')
Ejemplo n.º 54
0
 def test_write_returns_length_written(self):
     with tempfile.TemporaryFile() as f:
         stream = io.Stream(f)
         expect(stream.write('test')).to.equal(4)
Ejemplo n.º 55
0
 def test_reading_multiple_chunks(self):
     demuxer = io.Demuxer(self.create_fixture())
     expect(demuxer.read(32)).to.equal('foo')
     expect(demuxer.read(32)).to.equal('d')
Ejemplo n.º 56
0
 def test_write_to_file(self):
     with tempfile.TemporaryFile() as f:
         stream = io.Stream(f)
         stream.write('test')
         f.seek(0)
         expect(f.read(32)).to.equal('test')
Ejemplo n.º 57
0
 def test_write_returns_none_when_no_data(self):
     stream = io.Stream(StringIO())
     expect(stream.write('')).to.be.none
Ejemplo n.º 58
0
 def test_read_returns_empty_string_at_eof(self):
     with tempfile.TemporaryFile() as f:
         stream = io.Stream(f)
         expect(stream.read(32)).to.equal('')
Ejemplo n.º 59
0
 def test_rejects_dict(self):
     name = self.add_module(values={"outer": {"inner": 42}})
     expect(partial(config_for_module, name)).to(complain(TypeError))
Ejemplo n.º 60
0
 def test_none(self):
     key = "worries"
     name = self.add_module(values={key: None})
     actual = config_for_module(name)[key]
     expect(actual).to(be_a(type(None)))