def test_signals_resend_on_1st_call_after_flush_interval_with_errors(self):
        req = _make_test_request(self.SERVICE_NAME)
        failure_code = messages.CheckError.CodeValueValuesEnum.NOT_FOUND
        fake_response = messages.CheckResponse(
            operationId=self.FAKE_OPERATION_ID, checkErrors=[
                messages.CheckError(code=failure_code)
            ])
        agg = self.agg
        expect(agg.check(req)).to(be_none)
        agg.add_response(req, fake_response)
        expect(agg.check(req)).to(equal(fake_response))

        # Now flush interval is reached, but not the response expiry
        self.timer.tick() # now past the flush_interval
        expect(agg.check(req)).to(be_none)  # first response is null

        # until expiry, the response will continue to be returned
        expect(agg.check(req)).to(equal(fake_response))
        expect(agg.check(req)).to(equal(fake_response))

        # expire
        self.timer.tick()
        self.timer.tick() # now expired
        expect(agg.check(req)).to(be_none)
        expect(agg.check(req)).to(be_none) # 2nd check is None as well
    def test_should_not_enter_scheduler_for_cached_checks(self, sched, thread_class):
        thread_class.return_value.start.side_effect = lambda: old_div(1,0)
        self._subject.start()

        # confirm scheduler is created and initialized
        expect(sched.scheduler.called).to(be_true)
        scheduler = sched.scheduler.return_value
        expect(scheduler.enter.called).to(be_true)
        scheduler.reset_mock()

        # call check once, to a cache response
        dummy_request = _make_dummy_check_request(self.PROJECT_ID,
                                                  self.SERVICE_NAME)
        dummy_response = messages.CheckResponse(
            operationId=dummy_request.checkRequest.operation.operationId)
        t = self._mock_transport
        t.services.check.return_value = dummy_response
        expect(self._subject.check(dummy_request)).to(equal(dummy_response))
        t.reset_mock()

        # call check again - response is cached...
        expect(self._subject.check(dummy_request)).to(equal(dummy_response))
        expect(self._mock_transport.services.check.called).to(be_false)

        # ... the scheduler is not run
        expect(scheduler.run.called).to(be_false)
 def test_should_update_temp_response_with_actual(self):
     req = _make_test_request(self.SERVICE_NAME, self.FAKE_OPERATION_ID)
     temp_response = sc_messages.AllocateQuotaResponse(
         operationId=self.FAKE_OPERATION_ID)
     real_response = sc_messages.AllocateQuotaResponse(
         operationId=self.FAKE_OPERATION_ID,
         quotaMetrics=[sc_messages.MetricValueSet(
             metricName=u'a_float',
             metricValues=[
                 metric_value.create(
                     labels={
                         u'key1': u'value1',
                         u'key2': u'value2'},
                     doubleValue=1.1,
                 ),
             ]
         )]
     )
     agg = self.agg
     agg.allocate_quota(req)
     signature = quota_request.sign(req.allocateQuotaRequest)
     with agg._cache as cache:
         item = cache[signature]
         expect(item.response).to(equal(temp_response))
         expect(item.is_in_flight).to(be_true)
         agg.add_response(req, real_response)
         item = cache[signature]
         expect(item.response).to(equal(real_response))
         expect(item.is_in_flight).to(be_false)
 def test_should_send_requests_with_configured_header_api_key(self):
     wrappee = _DummyWsgiApp()
     control_client = mock.MagicMock(spec=client.Client)
     given = {
         u'wsgi.url_scheme': u'http',
         u'PATH_INFO': u'/uvw/method1/with_query_param',
         u'REMOTE_ADDR': u'192.168.0.3',
         u'HTTP_HOST': u'localhost',
         u'HTTP_APIKEYHEADER': u'my-header-value',
         u'HTTP_REFERER': u'example.myreferer.com',
         u'REQUEST_METHOD': u'GET'}
     dummy_response = 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-header-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-header-value'))
Esempio n. 5
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)
Esempio n. 6
0
    def test_should_return_ttl_cache_if_flush_interval_is_positive(self):
        delta = datetime.timedelta(seconds=1)
        should_be_ttl = [
            lambda timer: caches.create(
                caches.CheckOptions(num_entries=1, flush_interval=delta),
                timer=timer
            ),
            lambda timer: caches.create(
                caches.ReportOptions(num_entries=1, flush_interval=delta),
                timer=timer
            ),
        ]
        for testf in should_be_ttl:
            timer = _DateTimeTimer()
            sync_cache = testf(timer)
            expect(sync_cache).to(be_a(caches.LockedObject))
            with sync_cache as cache:
                expect(cache).to(be_a(caches.DequeOutTTLCache))
                expect(cache.timer()).to(equal(0))
                cache[1] = 1
                expect(set(cache)).to(equal({1}))
                expect(cache.get(1)).to(equal(1))
                timer.tick()
                expect(cache.get(1)).to(equal(1))
                timer.tick()
                expect(cache.get(1)).to(be_none)

            # Is still TTL without the custom timer
            sync_cache = testf(None)
            expect(sync_cache).to(be_a(caches.LockedObject))
            with sync_cache as cache:
                expect(cache).to(be_a(caches.DequeOutTTLCache))
def _expect_stats_eq_direct_calc_from_samples(d, samples):
    # pylint: disable=fixme
    # TODO: update this the sum of rho-squared
    want_mean = sum(samples) / len(samples)
    expect(d.mean).to(equal(want_mean))
    expect(d.maximum).to(equal(max(samples)))
    expect(d.minimum).to(equal(min(samples)))
Esempio n. 8
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'))
Esempio n. 9
0
    def it_should_handle_the_collison_and_insert_the_url_twice(self):
        uow = inject.instance('UnitOfWorkManager')
        with uow.start() as tx:
            s_url1 = tx.short_urls.get('SID-123')
            s_url2 = tx.short_urls.get('SID-321')

        expect(s_url1.url).to(equal(self.url))
        expect(s_url2.url).to(equal(self.url))
 def test_should_merge_stats_correctly(self):
     # TODO(add a check of the variance)
     for d1, d2, _ in self.merge_triples:
         distribution.merge(d1, d2)
         expect(d2.count).to(equal(2))
         expect(d2.mean).to(equal((_HIGH_SAMPLE + _LOW_SAMPLE) / 2))
         expect(d2.maximum).to(equal(_HIGH_SAMPLE))
         expect(d2.minimum).to(equal(_LOW_SAMPLE))
Esempio n. 11
0
    def it_should_insert_a_short_url(self):
        uow = inject.instance('UnitOfWorkManager')
        with uow.start() as tx:
            s_url = tx.short_urls.get(self.given_sid)

        expect(s_url).to(be_a(ShortUrl))
        expect(s_url.url).to(equal(self.url))
        expect(s_url.user).to(equal(user))
Esempio n. 12
0
 def test_should_ignores_lower_expiration(self):
     wanted_expiration = (
         self.AN_INTERVAL + datetime.timedelta(milliseconds=1))
     options = caches.CheckOptions(flush_interval=self.AN_INTERVAL,
                                   expiration=self.A_LOWER_INTERVAL)
     expect(options.flush_interval).to(equal(self.AN_INTERVAL))
     expect(options.expiration).to(equal(wanted_expiration))
     expect(options.expiration).not_to(equal(self.A_LOWER_INTERVAL))
 def test_should_construct_with_ok_expected_args(self):
     rules = self.subject_cls(logs=[u'wanted_log'],
                              metrics=self.WANTED_METRICS,
                              labels=self.WANTED_LABELS)
     expect(rules).not_to(be_none)
     expect(rules.logs).to(equal(set([u'wanted_log'])))
     expect(rules.metrics).to(equal(self.WANTED_METRICS))
     expect(rules.labels).to(equal(self.WANTED_LABELS))
Esempio n. 14
0
 def test_should_create_with_defaults(self):
     options = caches.CheckOptions()
     expect(options.num_entries).to(equal(
         caches.CheckOptions.DEFAULT_NUM_ENTRIES))
     expect(options.flush_interval).to(equal(
         caches.CheckOptions.DEFAULT_FLUSH_INTERVAL))
     expect(options.expiration).to(equal(
         caches.CheckOptions.DEFAULT_EXPIRATION))
 def test_should_use_the_latest_end_time_delta_merges(self):
     got = metric_value.merge(MetricKind.DELTA,
                              self.early_ending,
                              self.late_ending)
     expect(got.endTime).to(equal(self.late_ending.endTime))
     got = metric_value.merge(MetricKind.DELTA,
                              self.late_ending,
                              self.early_ending)
     expect(got.endTime).to(equal(self.late_ending.endTime))
Esempio n. 16
0
def test_set_blocking_changes_fd_flags():
    with tempfile.TemporaryFile() as f:
        io.set_blocking(f, False)
        flags = fcntl.fcntl(f, fcntl.F_GETFL)
        expect(flags & os.O_NONBLOCK).to(equal(os.O_NONBLOCK))

        io.set_blocking(f, True)
        flags = fcntl.fcntl(f, fcntl.F_GETFL)
        expect(flags & os.O_NONBLOCK).to(equal(0))
Esempio n. 17
0
 def test_should_detect_nothing_for_methods_with_no_registration(self):
     registry = self._get_registry()
     info = registry.lookup(u'GET', u'uvw/default_parameters')
     expect(info).not_to(be_none)
     expect(info.selector).to(equal(u'Uvw.DefaultParameters'))
     expect(info.url_query_param(u'name1')).to(equal(tuple()))
     expect(info.url_query_param(u'name2')).to(equal(tuple()))
     expect(info.header_param(u'name1')).to(equal(tuple()))
     expect(info.header_param(u'name2')).to(equal(tuple()))
Esempio n. 18
0
 def test_should_add_ok_when_nanos_have_different_signs(self):
     the_sum = money.add(self._SOME_YEN, self._SOME_YEN_DEBT)
     want_units = self._SOME_YEN_DEBT.units + self._SOME_YEN.units - 1
     expect(the_sum.units).to(equal(want_units))
     expect(the_sum.nanos).to(equal(money.MAX_NANOS))
     the_sum = money.add(self._SOME_MORE_YEN, self._SOME_YEN_DEBT)
     want_units = self._SOME_YEN_DEBT.units + self._SOME_YEN.units - 1
     expect(the_sum.units).to(equal(want_units))
     expect(the_sum.nanos).to(equal(1 - money.MAX_NANOS))
 def test_should_convert_using_as_quota_request(self):
     timer = _DateTimeTimer()
     for info, want in _INFO_TESTS:
         got = info.as_allocate_quota_request(timer=timer)
         # These additional properties have no well-defined order, so sort them.
         got.allocateQuotaRequest.allocateOperation.labels.additionalProperties.sort(key=KEYGETTER)
         want.labels.additionalProperties.sort(key=KEYGETTER)
         expect(got.allocateQuotaRequest.allocateOperation).to(equal(want))
         expect(got.serviceName).to(equal(_TEST_SERVICE_NAME))
 def test_should_add_expected_label_as_report_request(self):
     timer = _DateTimeTimer()
     rules = report_request.ReportingRules(labels=[
         _EXPECTED_OK_LABEL
     ])
     for info, want in _ADD_LABELS_TESTS:
         got = info.as_report_request(rules, timer=timer)
         expect(got.serviceName).to(equal(_TEST_SERVICE_NAME))
         expect(got.reportRequest.operations[0]).to(equal(want))
Esempio n. 21
0
 def test_should_detect_registered_system_parameters(self):
     registry = self._get_registry()
     info = registry.lookup(u'GET', u'uvw/method1/abc')
     expect(info).not_to(be_none)
     expect(info.selector).to(equal(u'Uvw.Method1'))
     expect(info.url_query_param(u'name1')).to(equal((u'param_key1',)))
     expect(info.url_query_param(u'name2')).to(equal((u'param_key2',)))
     expect(info.header_param(u'name1')).to(equal((u'Header-Key1',)))
     expect(info.header_param(u'name2')).to(equal((u'Header-Key2',)))
Esempio n. 22
0
def test_select_returns_streams_for_reading():
        a, b = socket.socketpair()
        a.send(b'test')
        expect(io.select([a, b], timeout=0)).to(equal([b]))
        b.send(b'test')
        expect(io.select([a, b], timeout=0)).to(equal([a, b]))
        b.recv(4)
        expect(io.select([a, b], timeout=0)).to(equal([a]))
        a.recv(4)
        expect(io.select([a, b], timeout=0)).to(equal([]))
Esempio n. 23
0
    def test_reading_data_from_slow_stream(self):
        slow_stream = SlowStream([
            b"\x01\x00\x00\x00\x00\x00\x00\x03f",
            b"oo",
            b"\x01\x00\x00\x00\x00\x00\x00\x01d",
        ])

        demuxer = io.Demuxer(slow_stream)
        expect(demuxer.read(32)).to(equal(b'foo'))
        expect(demuxer.read(32)).to(equal(b'd'))
Esempio n. 24
0
    def test_reading_size_from_slow_stream(self):
        slow_stream = SlowStream([
            "\x01\x00\x00\x00",
            "\x00\x00\x00\x03foo",
            "\x01\x00",
            "\x00\x00\x00\x00\x00\x01d",
        ])

        demuxer = io.Demuxer(slow_stream)
        expect(demuxer.read(32)).to(equal('foo'))
        expect(demuxer.read(32)).to(equal('d'))
 def test_should_include_project_id_in_error_text_when_needed(self):
     resp = sc_messages.AllocateQuotaResponse(
         allocateErrors = [
             sc_messages.QuotaError(
                 code=sc_messages.QuotaError.CodeValueValuesEnum.PROJECT_DELETED)
         ]
     )
     code, got = quota_request.convert_response(resp, self.PROJECT_ID)
     want = u'Project %s has been deleted' % (self.PROJECT_ID,)
     expect(code).to(equal(httplib.FORBIDDEN))
     expect(got).to(equal(want))
 def test_should_include_project_id_in_error_text_when_needed(self):
     resp = messages.CheckResponse(
         checkErrors = [
             messages.CheckError(
                 code=messages.CheckError.CodeValueValuesEnum.PROJECT_DELETED)
         ]
     )
     code, got, _ = check_request.convert_response(resp, self.PROJECT_ID)
     want = u'Project %s has been deleted' % (self.PROJECT_ID,)
     expect(code).to(equal(httplib.FORBIDDEN))
     expect(got).to(equal(want))
Esempio n. 27
0
 def test_should_queue_the_request_if_not_cached(self, dummy_thread_class):
     # the request isn't sent immediately as long as a cache exists
     # instead we get a temporary response
     self._subject.start()
     dummy_request = _make_dummy_quota_request(self.PROJECT_ID,
                                               self.SERVICE_NAME)
     resp = self._subject.allocate_quota(dummy_request)
     with self._subject._quota_aggregator._out as out_deque:
         expect(out_deque[0]).to(equal(dummy_request))
     expect(resp.operationId).to(equal(
         dummy_request.allocateQuotaRequest.allocateOperation.operationId))
Esempio n. 28
0
    def test_reading_size_from_slow_stream(self):
        slow_stream = SlowStream([
            b'\x01\x00\x00\x00',
            b'\x00\x00\x00\x03foo',
            b'\x01\x00',
            b'\x00\x00\x00\x00\x00\x01d',
        ])

        demuxer = io.Demuxer(slow_stream)
        expect(demuxer.read(32)).to(equal(b'foo'))
        expect(demuxer.read(32)).to(equal(b'd'))
 def test_should_add_expected_label_as_report_request(self):
     timer = _DateTimeTimer()
     rules = report_request.ReportingRules(labels=[
         _EXPECTED_OK_LABEL
     ])
     for info, want in _ADD_LABELS_TESTS:
         got = info.as_report_request(rules, timer=timer)
         # These additional properties have no well-defined order, so sort them.
         got.reportRequest.operations[0].labels.additionalProperties.sort(key=KEYGETTER)
         want.labels.additionalProperties.sort(key=KEYGETTER)
         expect(got.serviceName).to(equal(_TEST_SERVICE_NAME))
         expect(got.reportRequest.operations[0]).to(equal(want))
Esempio n. 30
0
    def test_get_d3_node_edge_representation_from_graph(self):
        parser = GraphParser()
        graph = {
                'a': ['b', 'c'],
                'b': ['a']
                }

        nodes, edges = parser.d3_representation(graph)

        expect(nodes).to(be_a(list))
        expect(set(nodes)).to(equal({'a', 'b', 'c'}))
        expect(edges).to(equal([('a', 'b'), ('a', 'c'), ('b', 'a')]))
Esempio n. 31
0
    bucket.has_file = Mock(return_value=has_file)
    bucket.get_file = Mock(return_value=file_name)
    return bucket


with description("Entry"):
    with it("should hash http-link form id's"):
        http_id = "http://example.com"
        entry = Entry(FeedParserDict(id=http_id), None)

        expect(entry.id).not_to(contain("http"))

    with it("should not change it if it is does not contain http"):
        entry = Entry(BASIC_INPUT_ENTRY, None)

        expect(entry.id).to(equal(EXAMPLE_ID))

    with it("should be marked as processed if the file with given id is in the bucket"
            ):
        entry = Entry(BASIC_INPUT_ENTRY, mock_bucket(True))

        expect(entry.processed).to(be(True))

    with it("should redirect unset fields to input_entry"):
        test_field = "whee"
        entry = Entry(FeedParserDict(id=EXAMPLE_ID, test_field=test_field),
                      None)

        expect(entry.test_field).to(equal(test_field))

    with it("should use file in the bucket if the file for given id exists"):
Esempio n. 32
0
from mamba import description, context, it
from expects import expect, equal, contain
from fractions import Fraction

from ly2abc.note import Key
from spec.ly2abc_spec_helper import *

with description('Key') as self:
    with it('takes a pitch and a mode'):
        expect(Key(Pitch.c, 'major')).not_to(equal(None))

    with description('sharps') as self:
        with it('has 0 sharps for Cmajor'):
            expect(Key(Pitch.c, 'major').sharps()).to(equal(0))

        with it('has 3 flats for Eb major'):
            expect(Key(Pitch.ef, 'major').sharps()).to(equal(-3))

        with it('has 4 sharps for E major'):
            expect(Key(Pitch.e, 'major').sharps()).to(equal(4))

        with it('has 3 flats for C minor'):
            expect(Key(Pitch.c, 'minor').sharps()).to(equal(-3))

        with it('has 0 sharps for D dorian'):
            expect(Key(Pitch.d, 'dorian').sharps()).to(equal(0))

        with it('has 2 sharps for A mixolydian'):
            expect(Key(Pitch.a, 'mixolydian').sharps()).to(equal(2))

        with it('has 9 sharps for D# major'):

def fibonacci(index):
    if index < 2:
        return index
    return fibonacci(index - 1) + fibonacci(index - 2)


with description('fibonacci specs'):
    with context('for the first two indexes'):
        with it('returns index'):
            expected_values = {0: 0, 1: 1}
            for index, expected_value in expected_values.items():
                value = fibonacci(index)

                expect(value).to(equal(expected_value))

    with context('for the rest of indexes'):
        with it('returns the sum of the previous two values'):
            expected_values = {
                2: 1,
                3: 2,
                4: 3,
                5: 5,
                6: 8,
                17: 1597,
            }
            for index, expected_value in expected_values.items():
                value = fibonacci(index)

                expect(value).to(equal(expected_value))
Esempio n. 34
0
 def test_max_if_list_of_string(self):
     e = List(['apple', 'bear', 'dog', 'plum'])
     expect(e.max()).to(equal('plum'))
Esempio n. 35
0
def test_version() -> None:
    expect(__version__).to(equal("0.1.0"))
Esempio n. 36
0
def test_startup_succeeds(runner: CliRunner, rom: str) -> None:
    rom_name = os.path.basename(rom)
    result = runner.invoke(cli.cli, [rom, "-i"])

    expect(result.exit_code).to(equal(0))
    expect(result.output).to(contain(f"ROM File: {rom_name}\n"))