Example #1
1
    def test_connection_error(self):
        """Connecting to an unknown domain should raise a ConnectionError"""
        with pytest.raises(ConnectionError):
            requests.get("http://fooobarbangbazbing.httpbin.org")

        with pytest.raises(ConnectionError):
            requests.get("http://httpbin.org:1")
    def test_connect_and_disconnect_container(self):
        net_name, net_id = self.create_network()

        container = self.client.create_container('busybox', 'top')
        self.tmp_containers.append(container)
        self.client.start(container)

        network_data = self.client.inspect_network(net_id)
        self.assertFalse(network_data.get('Containers'))

        self.client.connect_container_to_network(container, net_id)
        network_data = self.client.inspect_network(net_id)
        self.assertEqual(
            list(network_data['Containers'].keys()),
            [container['Id']])

        with pytest.raises(docker.errors.APIError):
            self.client.connect_container_to_network(container, net_id)

        self.client.disconnect_container_from_network(container, net_id)
        network_data = self.client.inspect_network(net_id)
        self.assertFalse(network_data.get('Containers'))

        with pytest.raises(docker.errors.APIError):
            self.client.disconnect_container_from_network(container, net_id)
Example #3
0
 def test_normal_function(self):
     i = [iter(range(100)) for x in range(3)]
     e = expandable_chain()
     e.extend(i)
     assert list(e) == list(range(100))*3
     for x in i + [e]:
         pytest.raises(StopIteration, x.__next__)
Example #4
0
def test_sample_weights_ne1(table):
    """Tests that a series of weights with total != 1 is not accepted"""
    with pytest.raises(ValueError):
        table.sample(table.num_rows, weights=[1/4, 1/4, 1/4, 1/6])

    with pytest.raises(ValueError):
        table.sample(table.num_rows, weights=[1/4, 1/4, 1/4, 1/2])
Example #5
0
    def test_nested_scope(self):
        from pandas.core.computation.ops import UndefinedVariableError
        engine = self.engine
        parser = self.parser
        # smoke test
        x = 1  # noqa
        result = pd.eval('x + 1', engine=engine, parser=parser)
        assert result == 2

        df = DataFrame(np.random.randn(5, 3))
        df2 = DataFrame(np.random.randn(5, 3))

        # don't have the pandas parser
        with pytest.raises(SyntaxError):
            df.query('(@df>0) & (@df2>0)', engine=engine, parser=parser)

        with pytest.raises(UndefinedVariableError):
            df.query('(df>0) & (df2>0)', engine=engine, parser=parser)

        expected = df[(df > 0) & (df2 > 0)]
        result = pd.eval('df[(df > 0) & (df2 > 0)]', engine=engine,
                         parser=parser)
        assert_frame_equal(expected, result)

        expected = df[(df > 0) & (df2 > 0) & (df[df > 0] > 0)]
        result = pd.eval('df[(df > 0) & (df2 > 0) & (df[df > 0] > 0)]',
                         engine=engine, parser=parser)
        assert_frame_equal(expected, result)
def test_pqueue_message_expiry(live_servicebus_config, partitioned_queue):
    client = ServiceBusClient(
        service_namespace=live_servicebus_config['hostname'],
        shared_access_key_name=live_servicebus_config['key_name'],
        shared_access_key_value=live_servicebus_config['access_key'],
        debug=True)
    import uuid
    queue_client = client.get_queue(partitioned_queue)
    
    with queue_client.get_sender() as sender:
        content = str(uuid.uuid4())
        message = Message(content)
        sender.send(message)

    with queue_client.get_receiver() as receiver:
        messages = receiver.fetch_next(timeout=10)
        assert len(messages) == 1
        time.sleep(30)
        assert messages[0].expired
        with pytest.raises(MessageLockExpired):
            messages[0].complete()
        with pytest.raises(MessageLockExpired):
            messages[0].renew_lock()

    with queue_client.get_receiver() as receiver:
        messages = receiver.fetch_next(timeout=30)
        assert len(messages) == 1
        print_message(messages[0])
        assert messages[0].header.delivery_count > 0
        messages[0].complete()
Example #7
0
def test_with_column(table):
    column_1 = [10, 20, 30, 40]
    column_2 = 'hello'
    table2 = table.with_column('new_col1', column_1)
    table3 = table2.with_column('new_col2', column_2)
    assert_equal(table, """
    letter | count | points
    a      | 9     | 1
    b      | 3     | 2
    c      | 3     | 2
    z      | 1     | 10
    """)
    assert_equal(table2, """
    letter | count | points | new_col1
    a      | 9     | 1      | 10
    b      | 3     | 2      | 20
    c      | 3     | 2      | 30
    z      | 1     | 10     | 40
    """)
    assert_equal(table3, """
    letter | count | points | new_col1 | new_col2
    a      | 9     | 1      | 10       | hello
    b      | 3     | 2      | 20       | hello
    c      | 3     | 2      | 30       | hello
    z      | 1     | 10     | 40       | hello
    """)

    with(pytest.raises(ValueError)):
        table.append_column('bad_col', [1, 2])
    with(pytest.raises(ValueError)):
        table.append_column(0, [1, 2, 3, 4])
Example #8
0
def test_cluster(some_clusters):
    """Test base functionality of :class:`~.db.Cluster`."""

    # Test empty cluster attributes.
    cluster = Cluster()
    assert cluster.size == 0
    assert cluster.size_urls == 0
    assert cluster.frequency == 0
    with pytest.raises(ValueError) as excinfo:
        cluster.span
    assert 'No urls' in str(excinfo.value)
    assert cluster.urls == []

    # Test clusters from database.
    with session_scope() as session:
        assert session.query(Cluster).count() == 5
        assert session.query(Cluster.sid).all() == \
            [(i,) for i in some_clusters]
        assert session.query(Cluster).filter_by(sid=0).one().size == 0
        assert session.query(Cluster).filter_by(sid=0).one().size_urls == 0
        assert session.query(Cluster).filter_by(sid=0).one().frequency == 0
        with pytest.raises(ValueError) as excinfo:
            session.query(Cluster).filter_by(sid=0).one().span
        assert 'No urls' in str(excinfo.value)
        assert session.query(Cluster).filter_by(sid=0).one().urls == []

        assert session.query(Cluster).get(1).format_copy() == \
            '1\t0\tFalse\ttest'
Example #9
0
 def test_reset_twice_error(self):
     with self.getcapture() as cap:
         print("hello")
         out, err = cap.readouterr()
     pytest.raises(ValueError, cap.stop_capturing)
     assert out == "hello\n"
     assert not err
Example #10
0
 def test_create_index_fails(self, sql):
     with pytest.raises(KeyError):
         create_index(sql, 'z', name='zidx')
     with pytest.raises(ValueError):
         create_index(sql, 'x')
     with pytest.raises(ValueError):
         create_index(sql, 'z')
Example #11
0
 def test_client_badconf(self):
     config = {'host': 'localhost'}
     pytest.raises(KeyError, AnalysisClient, config)
     config['port'] = TESTING_CONFIG['port']
     conn = AnalysisClient(config)
     conn.host == TESTING_CONFIG['host']
     conn.port == TESTING_CONFIG['port']
Example #12
0
def test_element_coerce_from(fx_test_doc):
    doc, _ = fx_test_doc
    doc.title_attr = 'coerce test'
    assert isinstance(doc.title_attr, TextElement)
    assert doc.title_attr.value == 'coerce test'
    with raises(TypeError):
        doc.title_attr = 123
    doc.multi_attr = [TextElement(value='a'), 'b']
    for e in doc.multi_attr:
        assert isinstance(e, TextElement)
    assert doc.multi_attr[0].value == 'a'
    assert doc.multi_attr[1].value == 'b'
    with raises(TypeError):
        doc.multi_attr = [TextElement(value='a'), 'b', 3]
    number = len(doc.multi_attr)
    doc.multi_attr.append('coerce test')
    assert len(doc.multi_attr) == number + 1
    for e in doc.multi_attr:
        assert isinstance(e, TextElement)
    assert doc.multi_attr[-1].value == 'coerce test'
    with raises(TypeError):
        doc.multi_attr.append(123)
    doc.multi_attr[0] = 'coerce test'
    assert isinstance(doc.multi_attr[0], TextElement)
    assert doc.multi_attr[0].value == 'coerce test'
    with raises(TypeError):
        doc.multi_attr[1] = 123
    doc.multi_attr[1:] = ['slice', 'test']
    for e in doc.multi_attr:
        assert isinstance(e, TextElement)
    assert doc.multi_attr[1].value == 'slice'
    assert doc.multi_attr[2].value == 'test'
    with raises(TypeError):
        doc.multi_attr[1:] = ['slice test', 123]
Example #13
0
  def test_strategy_attribute_replaced(self):
    sd = StrategyDict("sd")
    sd.strategy("add", "+", keep_name=True)(operator.add)
    sd.strategy("mul", "*", keep_name=True)(operator.mul)
    sd.strategy("sub", "-", keep_name=True)(operator.sub)

    # Replaces the strategy attribute, but keeps the strategy there
    sd.sub = 14
    assert set(sd.keys()) == {("add", "+"), ("mul", "*"), ("sub", "-",)}
    assert sd["sub"](5, 4) == 1
    assert sd.sub == 14

    # Removes the strategy with replaced attribute, keeping the attribute
    del sd["sub"] # Removes the strategy
    assert sd.sub == 14 # Still there
    assert set(sd.keys()) == {("add", "+"), ("mul", "*"), ("-",)}

    # Removes the replaced attribute, keeping the strategy
    sd.add = None
    assert sd.add is None
    assert sd["add"](3, 7) == 10
    del sd.add # Removes the attribute
    assert sd.add(4, 7) == 11 == sd["add"](4, 7)
    assert set(sd.keys()) == {("add", "+"), ("mul", "*"), ("-",)}

    # Removes the strategy whose attribute had been replaced
    del sd.add # Removes the strategy
    assert set(sd.keys()) == {("+",), ("mul", "*"), ("-",)}
    with pytest.raises(KeyError):
      sd["add"](5, 4)
    with pytest.raises(AttributeError):
      sd.add(5, 4)
Example #14
0
  def test_key2keys_value2keys(self):
    md = MultiKeyDict()
    md[1] = 7
    md[2] = 7
    md[3] = -4
    md[4] = -4
    md[-4] = 1
    assert md.key2keys(1) == md.key2keys(2) == (1, 2) == md.value2keys(7)
    assert md.key2keys(3) == md.key2keys(4) == (3, 4) == md.value2keys(-4)
    assert md.key2keys(-4) == (-4,) == md.value2keys(1)
    assert len(md) == 3

    del md[2]
    assert md.key2keys(1) == (1,) == md.value2keys(7)
    assert md.key2keys(3) == md.key2keys(4) == (3, 4) == md.value2keys(-4)
    assert md.key2keys(-4) == (-4,) == md.value2keys(1)
    assert len(md) == 3
    with pytest.raises(KeyError):
      md.key2keys(2)

    del md[1]
    assert md.value2keys(7) == tuple()
    assert md.key2keys(3) == md.key2keys(4) == (3, 4) == md.value2keys(-4)
    assert md.key2keys(-4) == (-4,) == md.value2keys(1)
    assert len(md) == 2
    with pytest.raises(KeyError):
      md.key2keys(1)
    with pytest.raises(KeyError):
      md.key2keys(2)
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deletemode(live_servicebus_config, partitioned_queue):
    client = ServiceBusClient(
        service_namespace=live_servicebus_config['hostname'],
        shared_access_key_name=live_servicebus_config['key_name'],
        shared_access_key_value=live_servicebus_config['access_key'],
        debug=True)

    queue_client = client.get_queue(partitioned_queue)
    deferred_messages = []
    messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
    for m in messages:
        m.partition_key = "MyPartitionKey"
    results = queue_client.send(messages)
    assert all(result[0] for result in results)

    count = 0
    receiver = queue_client.get_receiver(idle_timeout=5)
    for message in receiver:
        deferred_messages.append(message.sequence_number)
        print_message(message)
        count += 1
        message.defer()

    assert count == 10
    with queue_client.get_receiver(idle_timeout=5) as receiver:
        deferred = receiver.receive_deferred_messages(deferred_messages, mode=ReceiveSettleMode.ReceiveAndDelete)
        assert len(deferred) == 10
        for message in deferred:
            assert isinstance(message, DeferredMessage)
            with pytest.raises(MessageAlreadySettled):
                message.complete()
        with pytest.raises(ServiceBusError):
            deferred = receiver.receive_deferred_messages(deferred_messages)
Example #16
0
def test_vel_transformation_obstime_err():
    # TODO: replace after a final decision on PR #6280
    from astropy.coordinates.sites import get_builtin_sites

    diff = r.CartesianDifferential([.1, .2, .3]*u.km/u.s)
    rep = r.CartesianRepresentation([1, 2, 3]*u.au, differentials=diff)

    loc = get_builtin_sites()['example_site']

    aaf = AltAz(obstime='J2010', location=loc)
    aaf2 = AltAz(obstime=aaf.obstime + 3*u.day, location=loc)
    aaf3 = AltAz(obstime=aaf.obstime + np.arange(3)*u.day, location=loc)
    aaf4 = AltAz(obstime=aaf.obstime, location=loc)

    aa = aaf.realize_frame(rep)

    with pytest.raises(NotImplementedError) as exc:
        aa.transform_to(aaf2)
    assert 'cannot transform' in exc.value.args[0]

    with pytest.raises(NotImplementedError) as exc:
        aa.transform_to(aaf3)
    assert 'cannot transform' in exc.value.args[0]

    aa.transform_to(aaf4)

    aa.transform_to(ICRS())
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_not_found(live_servicebus_config, partitioned_queue):
    client = ServiceBusClient(
        service_namespace=live_servicebus_config['hostname'],
        shared_access_key_name=live_servicebus_config['key_name'],
        shared_access_key_value=live_servicebus_config['access_key'],
        debug=True)

    queue_client = client.get_queue(partitioned_queue)
    deferred_messages = []
    with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:

        with queue_client.get_sender() as sender:
            for i in range(3):
                message = Message("Deferred message no. {}".format(i))
                message.partition_key = "MyPartitionKey"
                sender.send(message)

        count = 0
        for message in receiver:
            deferred_messages.append(message.sequence_number)
            print_message(message)
            count += 1
            message.defer()

    assert count == 3

    with pytest.raises(ServiceBusError):
        deferred = queue_client.receive_deferred_messages([3, 4], mode=ReceiveSettleMode.PeekLock)

    with pytest.raises(ServiceBusError):
        deferred = queue_client.receive_deferred_messages([5, 6, 7], mode=ReceiveSettleMode.PeekLock)
Example #18
0
    def test_setitem_ndarray_1d(self):
        # GH5508

        # len of indexer vs length of the 1d ndarray
        df = DataFrame(index=Index(lrange(1, 11)))
        df['foo'] = np.zeros(10, dtype=np.float64)
        df['bar'] = np.zeros(10, dtype=np.complex)

        # invalid
        def f():
            df.loc[df.index[2:5], 'bar'] = np.array([2.33j, 1.23 + 0.1j,
                                                     2.2, 1.0])

        pytest.raises(ValueError, f)

        # valid
        df.loc[df.index[2:6], 'bar'] = np.array([2.33j, 1.23 + 0.1j,
                                                 2.2, 1.0])

        result = df.loc[df.index[2:6], 'bar']
        expected = Series([2.33j, 1.23 + 0.1j, 2.2, 1.0], index=[3, 4, 5, 6],
                          name='bar')
        tm.assert_series_equal(result, expected)

        # dtype getting changed?
        df = DataFrame(index=Index(lrange(1, 11)))
        df['foo'] = np.zeros(10, dtype=np.float64)
        df['bar'] = np.zeros(10, dtype=np.complex)

        def f():
            df[2:5] = np.arange(1, 4) * 1j

        pytest.raises(ValueError, f)
def test_pqueue_message_receive_and_delete(live_servicebus_config, partitioned_queue):
    client = ServiceBusClient(
        service_namespace=live_servicebus_config['hostname'],
        shared_access_key_name=live_servicebus_config['key_name'],
        shared_access_key_value=live_servicebus_config['access_key'],
        debug=True)
    queue_client = client.get_queue(partitioned_queue)
    
    with queue_client.get_sender() as sender:
        message = Message("Receive and delete test")
        sender.send(message)

    with queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete) as receiver:
        messages = receiver.fetch_next(timeout=10)
        assert len(messages) == 1
        received = messages[0]
        print_message(received)
        with pytest.raises(MessageAlreadySettled):
            received.complete()
        with pytest.raises(MessageAlreadySettled):
            received.abandon()
        with pytest.raises(MessageAlreadySettled):
            received.defer()
        with pytest.raises(MessageAlreadySettled):
            received.dead_letter()
        with pytest.raises(MessageAlreadySettled):
            received.renew_lock()

    time.sleep(30)

    with queue_client.get_receiver() as receiver:
        messages = receiver.fetch_next(timeout=10)
        for m in messages:
            print_message(m)
        assert len(messages) == 0
Example #20
0
def test_remove(registry, what2nick):

    what, whatid, nick = what2nick

    # remove by nickname
    assert what == registry.register(what, nick)
    assert registry.list() == [(nick, whatid)]
    registry.remove(nickname=nick)
    assert registry.list() == []

    # remove by whatid
    assert what == registry.register(what, nick)
    assert registry.list() == [(nick, whatid)]
    registry.remove(what=what)
    assert registry.list() == []

    # remove by both need to match the entry
    assert what == registry.register(what, nick)
    assert registry.list() == [(nick, whatid)]
    with pytest.raises(ValueError):
        registry.remove(what=what, nickname='NO')
    assert registry.list() == [(nick, whatid)]
    with pytest.raises(ValueError):
        registry.remove(what='NO()', nickname=nick)

    # remove does not accept None parameters
    with pytest.raises(ValueError) as excinfo:
        registry.remove()
    assert 'at least one of nickname or what must be provided' == str(excinfo.value)
Example #21
0
def test_relabel():
    table = Table([(1, 2, 3), (12345, 123, 5123)], ['points', 'id'])
    table.relabel('id', 'todo')
    assert_equal(table, """
    points | todo
    1      | 12345
    2      | 123
    3      | 5123
    """)
    table.relabel(1, 'yolo')
    assert_equal(table, """
    points | yolo
    1      | 12345
    2      | 123
    3      | 5123
    """)
    table.relabel(['points', 'yolo'], ['red', 'blue'])
    assert_equal(table, """
    red    | blue
    1      | 12345
    2      | 123
    3      | 5123
    """)
    with(pytest.raises(ValueError)):
        table.relabel(['red', 'blue'], ['magenta', 'cyan', 'yellow'])
    with(pytest.raises(ValueError)):
        table.relabel(['red', 'green'], ['magenta', 'yellow'])
Example #22
0
def test_terminal_functions(terminal):

    terminal.flash()
    assert curses.flash.called

    terminal.getch()
    assert terminal.stdscr.getch.called

    with pytest.raises(RuntimeError):
        with terminal.no_delay():
            raise RuntimeError()
    terminal.stdscr.nodelay.assert_any_call(0)
    terminal.stdscr.nodelay.assert_any_call(1)

    curses.endwin.reset_mock()
    curses.doupdate.reset_mock()
    with terminal.suspend():
        pass
    assert curses.endwin.called
    assert curses.doupdate.called

    curses.endwin.reset_mock()
    curses.doupdate.reset_mock()
    with pytest.raises(RuntimeError):
        with terminal.suspend():
            raise RuntimeError()
    assert curses.endwin.called
    assert curses.doupdate.called

    terminal.addch(terminal.stdscr, 3, 5, 'ch', 'attr')
    terminal.stdscr.addch.assert_called_with(3, 5, 'ch', 'attr')
Example #23
0
def test_save_store_fs_change_pootle_path_or_store(en_tutorial_po_fs_store):
    """You cant change a pootle_path if a store is associated
    unless you also remove the store association - and vice versa
    """
    fs_store = en_tutorial_po_fs_store
    store = fs_store.store
    other_path = "/en/tutorial/other.po"

    fs_store.pootle_path = other_path
    with pytest.raises(ValidationError):
        fs_store.save()
    fs_store.store = None
    fs_store.save()

    assert fs_store.store is None
    assert fs_store.pootle_path == other_path

    fs_store.store = store
    with pytest.raises(ValidationError):
        fs_store.save()

    fs_store.pootle_path = store.pootle_path
    fs_store.save()

    assert fs_store.store == store
    assert fs_store.pootle_path == store.pootle_path
Example #24
0
def test_UnitConverter_nodistance():

    mywcs = WCS(hdr)

    convert = UnitConverter(mywcs)

    assert convert.ang_size.value == np.abs(hdr['CDELT2'])
    assert convert.ang_size.unit == mywcs.wcs.cunit[0]

    twopix_ang = np.abs(hdr['CDELT2']) * 2 * u.deg
    assert convert.to_pixel(twopix_ang).value == 2.

    assert convert.to_pixel_area(twopix_ang**2) == 4 * u.pix**2

    assert convert.from_pixel(2 * u.pix, u.deg) == twopix_ang
    assert convert.to_angular(2 * u.pix, u.deg) == twopix_ang

    # Round trip
    assert convert.to_pixel(convert.from_pixel(2 * u.pix, u.deg)) == 2 * u.pix
    assert convert.to_pixel(convert.to_angular(2 * u.pix, u.deg)) == 2 * u.pix

    assert convert.from_pixel(convert.to_pixel(twopix_ang), u.deg) == twopix_ang
    assert convert.to_angular(convert.to_pixel(twopix_ang), u.deg) == twopix_ang

    # Physical conversions should fail
    with pytest.raises(AttributeError):
        convert.from_pixel(2 * u.pix, u.pc)
    with pytest.raises(AttributeError):
        assert convert.to_physical(2 * u.pix, u.pc)
Example #25
0
 def test_getitem(self):
     c = caching_iter(range(20))
     assert c[-1] == 19
     with pytest.raises(IndexError):
         operator.getitem(c, -21)
     with pytest.raises(IndexError):
         operator.getitem(c, 21)
Example #26
0
def test_fetch_file(url, tmpdir):
    """Test URL retrieval."""
    tempdir = str(tmpdir)
    archive_name = op.join(tempdir, "download_test")
    with catch_logging() as log:
        _fetch_file(url, archive_name, timeout=30., verbose='debug')
    log = log.getvalue()
    assert 'Resuming at' not in log
    with open(archive_name, 'rb') as fid:
        data = fid.read()
    stop = len(data) // 2
    assert 0 < stop < len(data)
    with open(archive_name + '.part', 'wb') as fid:
        fid.write(data[:stop])
    with catch_logging() as log:
        _fetch_file(url, archive_name, timeout=30., verbose='debug')
    log = log.getvalue()
    assert 'Resuming at %s' % stop in log
    with pytest.raises(Exception, match='unknown url type'):
        _fetch_file('NOT_AN_ADDRESS', op.join(tempdir, 'test'), verbose=False)
    resume_name = op.join(tempdir, "download_resume")
    # touch file
    with open(resume_name + '.part', 'w'):
        os.utime(resume_name + '.part', None)
    _fetch_file(url, resume_name, resume=True, timeout=30.,
                verbose=False)
    with pytest.raises(ValueError, match='Bad hash value'):
        _fetch_file(url, archive_name, hash_='a', verbose=False)
    with pytest.raises(RuntimeError, match='Hash mismatch'):
        _fetch_file(url, archive_name, hash_='a' * 32, verbose=False)
Example #27
0
def test_parse_provides_useful_errors():
    with raises(LanguageError) as excinfo:
        parse("""{""")
    assert (
               u'Syntax Error GraphQL (1:2) Expected Name, found EOF\n'
               u'\n'
               u'1: {\n'
               u'    ^\n'
               u''
           ) == excinfo.value.message

    assert excinfo.value.positions == [1]
    assert excinfo.value.locations == [SourceLocation(line=1, column=2)]

    with raises(LanguageError) as excinfo:
        parse("""{ ...MissingOn }
fragment MissingOn Type
""")
    assert 'Syntax Error GraphQL (2:20) Expected "on", found Name "Type"' in str(excinfo.value)

    with raises(LanguageError) as excinfo:
        parse('{ field: {} }')
    assert 'Syntax Error GraphQL (1:10) Expected Name, found {' in str(excinfo.value)

    with raises(LanguageError) as excinfo:
        parse('notanoperation Foo { field }')
    assert 'Syntax Error GraphQL (1:1) Unexpected Name "notanoperation"' in str(excinfo.value)

    with raises(LanguageError) as excinfo:
        parse('...')
    assert 'Syntax Error GraphQL (1:1) Unexpected ...' in str(excinfo.value)
def test_pqueue_by_servicebus_client_iter_messages_simple(live_servicebus_config, partitioned_queue):
    client = ServiceBusClient(
        service_namespace=live_servicebus_config['hostname'],
        shared_access_key_name=live_servicebus_config['key_name'],
        shared_access_key_value=live_servicebus_config['access_key'],
        debug=True)

    queue_client = client.get_queue(partitioned_queue)
    with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:

        with queue_client.get_sender() as sender:
            for i in range(10):
                message = Message("Iter message no. {}".format(i))
                sender.send(message)

        count = 0
        for message in receiver:
            print_message(message)
            message.complete()
            with pytest.raises(MessageAlreadySettled):
                message.complete()
            with pytest.raises(MessageAlreadySettled):
                message.renew_lock()
            count += 1

        with pytest.raises(InvalidHandlerState):
            next(receiver)
    assert count == 10
Example #29
0
def test_check_config(tmpdir, registry):

    test_path = str(tmpdir / "test.json")

    with open(test_path, "w+", encoding="utf-8") as f:
        f.write("")

    with pytest.raises(ApplianceError):
        Appliance(registry, "jkhj")

    with pytest.raises(ApplianceError):
        Appliance(registry, test_path)

    with open(test_path, "w+", encoding="utf-8") as f:
        f.write("{}")

    with pytest.raises(ApplianceError):
        Appliance(registry, test_path)

    with pytest.raises(ApplianceError):
        with open(test_path, "w+", encoding="utf-8") as f:
            f.write('{"registry_version": 42}')
        Appliance(registry, test_path)

    Appliance(registry, "tests/registry/appliances/microcore-linux.json")
Example #30
0
def test_circular_cone_flat():
    """Conebeam geometry with circular acquisition and a flat 2D detector."""

    # Parameters
    full_angle = np.pi
    apart = odl.uniform_partition(0, full_angle, 10)
    dpart = odl.uniform_partition([0, 0], [1, 1], [10, 10])
    src_rad = 10
    det_rad = 5

    with pytest.raises(TypeError):
        odl.tomo.CircularConeFlatGeometry([0, 1], dpart, src_rad, det_rad)
    with pytest.raises(TypeError):
        odl.tomo.CircularConeFlatGeometry(apart, [0, 1], src_rad, det_rad)
    with pytest.raises(ValueError):
        odl.tomo.CircularConeFlatGeometry(apart, dpart, -1, det_rad)
    with pytest.raises(ValueError):
        odl.tomo.CircularConeFlatGeometry(apart, dpart, src_rad, -1)

    # Initialize
    geom = odl.tomo.CircularConeFlatGeometry(apart, dpart, src_rad, det_rad)

    assert all_almost_equal(geom.angles, apart.points().ravel())

    with pytest.raises(ValueError):
        geom.det_refpoint(2 * full_angle)

    assert geom.ndim == 3
    assert np.linalg.norm(geom.det_refpoint(0)) == det_rad
    assert np.linalg.norm(geom.src_position(np.pi)) == src_rad
    assert isinstance(geom.detector, odl.tomo.Flat2dDetector)

    # check str and repr work without crashing and return something
    assert str(geom)
    assert repr(geom)