def test_make_parsed_url_asserts_with_conflicting_port_numbers(self): with ExpectedException(AssertionError): netloc = "%s:%d" % (factory.make_hostname(), factory.pick_port()) factory.make_parsed_url(netloc=netloc, port=factory.pick_port()) with ExpectedException(AssertionError): netloc = "%s:%d" % (factory.make_hostname(), factory.pick_port()) factory.make_parsed_url(netloc=netloc, port=True)
def test_configuration_manager(self, mock_strategy): mock_strategy.count_revisions.return_value = 0 manager = ConfigurationManager(Mock(), Mock(), Mock(), Mock()) with ExpectedException(exception.DatastoreOperationNotSupported): manager.update_override({}) with ExpectedException(exception.DatastoreOperationNotSupported): manager.remove_override() manager.set_override_strategy(mock_strategy, 1) self.assertEqual(1, manager.max_num_overrides) self.assertEqual(0, manager.current_revision) with ExpectedException( exception.UnprocessableEntity, "The maximum number of attached Configuration Groups cannot " "be negative."): manager.max_num_overrides = -1 manager.max_num_overrides = 2 self.assertEqual(2, manager.max_num_overrides) self.assertEqual(0, manager.current_revision) manager.update_override({}) self.assertEqual(1, manager.current_revision) manager.update_override({}) self.assertEqual(2, manager.current_revision) with ExpectedException( ConfigurationError, "This instance cannot have more than " "'2' Configuration Groups attached."): manager.update_override({}) self.assertEqual(2, manager.current_revision) manager.remove_override() self.assertEqual(1, manager.current_revision) manager.update_override({}) self.assertEqual(2, manager.current_revision) manager.remove_override() self.assertEqual(1, manager.current_revision) manager.remove_override() self.assertEqual(0, manager.current_revision) with ExpectedException( ConfigurationError, "This instance does not have a Configuration Group attached."): manager.remove_override() self.assertEqual(0, manager.current_revision) manager.override_strategy = None self.assertEqual(0, manager.max_num_overrides) self.assertEqual(0, manager.current_revision)
def _test_rebuild(self, stgpol, data_size, broken_pos_list, full_rebuild_pos): data = random_data(data_size) content, broken_chunks_info = self._new_content( stgpol, data, broken_pos_list) rebuild_pos, rebuild_idx = full_rebuild_pos rebuild_chunk_info = broken_chunks_info[rebuild_pos][rebuild_idx] content.rebuild_chunk(rebuild_chunk_info["id"]) # get the new structure of the content rebuilt_content = self.content_factory.get(self.container_id, content.content_id) self.assertEqual(type(rebuilt_content), DupContent) # find the rebuilt chunk for c in rebuilt_content.chunks.filter(pos=rebuild_pos): if len(content.chunks.filter(id=c.id)) > 0: # not the rebuilt chunk # if this chunk is broken, it must not have been rebuilt for b_c_i in broken_chunks_info[rebuild_pos].values(): if c.id == b_c_i["id"]: with ExpectedException(NotFound): _, _ = self.blob_client.chunk_get(c.url) continue meta, stream = self.blob_client.chunk_get(c.url) self.assertEqual(meta["chunk_id"], c.id) self.assertEqual(md5_stream(stream), rebuild_chunk_info["dl_hash"]) self.assertEqual(c.hash, rebuild_chunk_info["hash"]) self.assertThat(c.url, NotEquals(rebuild_chunk_info["url"])) del meta["chunk_id"] del rebuild_chunk_info["dl_meta"]["chunk_id"] self.assertEqual(meta, rebuild_chunk_info["dl_meta"])
def test_pending_transaction(self): """When a transaction is pending before the operation, raise.""" transaction.begin() with ExpectedException(AssertionError, 'Transaction open before operation'): with TransactionFreeOperation(): pass
def _rebuild_and_check(self, content, broken_chunks_info, full_rebuild_pos, allow_frozen_container=False): rebuild_pos, rebuild_idx = full_rebuild_pos rebuild_chunk_info = broken_chunks_info[rebuild_pos][rebuild_idx] content.rebuild_chunk(rebuild_chunk_info["id"], allow_frozen_container=allow_frozen_container) # get the new structure of the content rebuilt_content = self.content_factory.get(self.container_id, content.content_id) # find the rebuilt chunk for c in rebuilt_content.chunks.filter(pos=rebuild_pos): if len(content.chunks.filter(id=c.id)) > 0: # not the rebuilt chunk # if this chunk is broken, it must not have been rebuilt for b_c_i in broken_chunks_info[rebuild_pos].values(): if c.id == b_c_i["id"]: with ExpectedException(NotFound): _, _ = self.blob_client.chunk_get(c.url) continue meta, stream = self.blob_client.chunk_get(c.url) self.assertEqual(meta["chunk_id"], c.id) self.assertEqual(md5_stream(stream), rebuild_chunk_info["dl_hash"]) self.assertEqual(c.checksum, rebuild_chunk_info["hash"]) self.assertThat(c.url, NotEquals(rebuild_chunk_info["url"])) del meta["chunk_id"] del rebuild_chunk_info["dl_meta"]["chunk_id"] self.assertEqual(meta, rebuild_chunk_info["dl_meta"])
def test_cannot_be_acquired_twice(self): """ `SystemLock` and its kin do not suffer from a bug that afflicts ``lockfile`` (https://pypi.python.org/pypi/lockfile): >>> from lockfile import FileLock >>> with FileLock('foo'): ... with FileLock('foo'): ... print("Hello!") ... Hello! Traceback (most recent call last): File "<stdin>", line 3, in <module> File ".../dist-packages/lockfile.py", line 230, in __exit__ self.release() File ".../dist-packages/lockfile.py", line 271, in release raise NotLocked lockfile.NotLocked """ lock = self.make_lock() with lock: with ExpectedException(self.locktype.NotAvailable, lock.path): with lock: pass
def test_connection_raises_NoRabbit_if_cannot_connect(self): # Attempt to connect to a RabbitMQ on the local "discard" # service. The connection will be refused. self.patch(settings, 'RABBITMQ_HOST', 'localhost:9') session = RabbitSession() with ExpectedException(NoRabbit): session.connection
def test_list_boot_images_passes_on_other_exceptions(self): # OSError(EACCESS) is transmogrified, by Python itself, into # PermissionError. It's a subclass of OSError. error = OSError(errno.EACCES, "Deliberate error for testing.") self.patch(tftppath, 'list_subdirs', Mock(side_effect=error)) with ExpectedException(PermissionError): list_boot_images(factory.make_string())
def test_utf8_container(self): backend = AccountBackend({}, self.conn) account_id = 'test' self.assertEqual(backend.create_account(account_id), account_id) name = u'La fête à la maison' mtime = Timestamp(time()).normal # create container backend.update_container(account_id, name, mtime, 0, 0, 0, 0, 0) res = self.conn.zrangebylex('containers:%s' % account_id, '-', '+') self.assertEqual(unicode(res[0], 'utf8'), name) # ensure it appears in listing listing = backend.list_containers(account_id, marker='', delimiter='', limit=100) self.assertIn(name, [entry[0] for entry in listing]) # delete container sleep(.00001) dtime = Timestamp(time()).normal backend.update_container(account_id, name, 0, dtime, 0, 0, 0, 0) res = self.conn.zrangebylex('containers:%s' % account_id, '-', '+') self.assertEqual(len(res), 0) self.assertTrue( self.conn.ttl('container:%s:%s' % (account_id, name)) >= 1) # ensure it has been removed with ExpectedException(Conflict): backend.update_container(account_id, name, 0, dtime, 0, 0, 0, 0) res = self.conn.zrangebylex('containers:%s' % account_id, '-', '+') self.assertEqual(len(res), 0) self.assertTrue( self.conn.ttl('container:%s:%s' % (account_id, name)) >= 1)
def test__raises_when_inner_encapsulation_is_not_bson(self): self.write_secret() payload = fernet_encrypt_psk(compress(b"\n\n"), raw=True) packet = _make_beacon_payload(payload=payload) with ExpectedException(InvalidBeaconingPacket, ".*beacon payload is not BSON.*"): read_beacon_payload(packet)
def test__raises_when_inner_encapsulation_does_not_decompress(self): self.write_secret() packet = _make_beacon_payload( payload=fernet_encrypt_psk('\n\n', raw=True)) with ExpectedException(InvalidBeaconingPacket, ".*Failed to decompress.*"): read_beacon_payload(packet)
def test__raises_when_inner_payload_does_not_decrypt(self): self.write_secret() packet = _make_beacon_payload(payload=b"\xfe") with ExpectedException( InvalidBeaconingPacket, ".*Failed to decrypt.*" ): read_beacon_payload(packet)
def test__requires_input_file(self): parser = ArgumentParser() add_arguments(parser) args = parser.parse_args([]) with ExpectedException(ActionScriptError, ".*Required argument: interface.*"): run(args)
def test_passes_on_dissimilar_errors(self): class DeliberateError(Exception): """Deliberately induced error for testing.""" with ExpectedException(DeliberateError): with report_missing_config_dir(): raise DeliberateError("This exception propagates unchanged.")
def test_raises_last_exception_after_all_retries_fail(self): wait_time = [random.randrange(1, 10) for _ in range(3)] driver = make_power_driver(wait_time=wait_time) exception_types = list( factory.make_exception_type((PowerError, )) for _ in wait_time) self.patch(driver, "power_query").side_effect = exception_types with ExpectedException(exception_types[-1]): yield driver.query(sentinel.system_id, sentinel.context)
def test_install_agent(self): blueprint_path = os.path.join( os.path.dirname(os.path.realpath(__file__)), "resources/blueprints/test-install-agent-blueprint.yaml") with ExpectedException(ValueError, "'install_agent': true is not supported*"): self.env = local.init_env(blueprint_path)
def test__discover_requires_client_to_have_vm_support(self): context = self.make_parameters_context() driver = LXDPodDriver() Client = self.patch(lxd_pod_module, "Client") client = Client.return_value client.has_api_extension.return_value = False with ExpectedException(lxd_pod_module.LXDError): yield driver.discover(None, context)
def test_pauses_between_retries(self): wait_time = [random.randrange(1, 10) for _ in range(3)] driver = make_power_driver(wait_time=wait_time) self.patch(driver, 'power_query').side_effect = PowerError with ExpectedException(PowerError): yield driver.query(sentinel.system_id, sentinel.context) self.assertThat(power.pause, MockCallsMatch( *(call(wait, reactor) for wait in wait_time)))
def test_secrecy_change_unprivileged(self): """Unprivileged users cannot change information_type.""" policy = SpecificationSharingPolicy.PUBLIC_OR_PROPRIETARY product = self.factory.makeProduct(specification_sharing_policy=policy) spec = self.factory.makeSpecification(product=product) person = self.factory.makePerson() with ExpectedException(Unauthorized): self.set_secrecy(spec, person) self.assertEqual(InformationType.PUBLIC, spec.information_type)
def test_validates_mtu(self): vlan = factory.make_VLAN() vlan.mtu = self.mtu if self.valid: # No exception. self.assertIsNone(vlan.save()) else: with ExpectedException(ValidationError): vlan.save()
def test_handles_non_fatal_error(self): system_id = factory.make_name("system_id") context = {"context": factory.make_name("context")} driver = make_power_driver(wait_time=[0]) mock_on = self.patch(driver, self.action_func) mock_on.side_effect = PowerError() method = getattr(driver, self.action) with ExpectedException(PowerError): yield method(system_id, context)
def test_power_query_raises_error_on_unknown_state(self): context = self.make_parameters_context() pod_id = factory.make_name("pod_id") driver = lxd_module.LXDPodDriver() mock_machine = self.patch(driver, "get_machine").return_value mock_machine.status_code = 106 error_msg = f"Pod {pod_id}: Unknown power status code: {mock_machine.status_code}" with ExpectedException(lxd_module.LXDPodError, error_msg): yield driver.power_query(pod_id, context)
def test_get_client_raises_error_when_cannot_connect(self): context = self.make_parameters_context() pod_id = factory.make_name("pod_id") Client = self.patch(lxd_module, "Client") Client.side_effect = lxd_module.ClientConnectionFailed() driver = lxd_module.LXDPodDriver() error_msg = f"Pod {pod_id}: Failed to connect to the LXD REST API." with ExpectedException(lxd_module.LXDPodError, error_msg): yield driver.get_client(pod_id, context)
def test_atomic_write_does_not_leak_temp_file_on_failure(self): # If the overwrite fails, atomic_write does not leak its # temporary file. self.patch(fs_module, "rename", Mock(side_effect=OSError())) filename = self.make_file() with ExpectedException(OSError): atomic_write(factory.make_bytes(), filename) self.assertEqual([os.path.basename(filename)], os.listdir(os.path.dirname(filename)))
def test_connection_propagates_exceptions(self): def fail(*args, **kwargs): raise socket.error("Connection not refused, but failed anyway.") self.patch(amqp, 'Connection', fail) session = RabbitSession() with ExpectedException(socket.error): session.connection
def test_probe_and_enlist_login_failure(self): user = factory.make_name('user') poweraddr = factory.make_name('poweraddr') mock_login = self.patch(virsh.VirshSSH, 'login') mock_login.return_value = False with ExpectedException(virsh.VirshError): yield deferToThread(virsh.probe_virsh_and_enlist, user, poweraddr, password=factory.make_string())
def test_refuses_EMBARGOED(self): """Packaging cannot be created for EMBARGOED productseries""" product = self.factory.makeProduct( information_type=InformationType.EMBARGOED) sp = self.makeSourcePackage() series = self.factory.makeProductSeries(product=product) with ExpectedException(CannotPackageProprietaryProduct, 'Only Public project series can be packaged, not Embargoed.'): series.setPackaging( sp.distroseries, sp.sourcepackagename, series.owner)
def test_raises_integrity_error_if_reconnecting_fails(self): # Here we test a corner case: we test that the DB refuses to # leave an interface without a VLAN in case the reconnection # fails when a VLAN is deleted. vlan = factory.make_VLAN() # Break 'manage_connected_interfaces'. self.patch(vlan, 'manage_connected_interfaces') factory.make_Interface(INTERFACE_TYPE.PHYSICAL, vlan=vlan) with ExpectedException(ProtectedError): vlan.delete()
def test_delete_container(self): account_id = 'test' self.assertEqual(self.backend.create_account(account_id), account_id) name = 'c' old_mtime = Timestamp(time() - 1).normal mtime = Timestamp(time()).normal # initial container self.backend.update_container(account_id, name, mtime, 0, 0, 0, 0, 0) res = self.backend.conn.zrangebylex('containers:%s' % account_id, '-', '+') self.assertEqual(res[0], name) # delete event sleep(.00001) dtime = Timestamp(time()).normal self.backend.update_container(account_id, name, mtime, dtime, 0, 0, 0, 0) res = self.backend.conn.zrangebylex('containers:%s' % account_id, '-', '+') self.assertEqual(len(res), 0) self.assertTrue( self.backend.conn.ttl('container:%s:%s' % (account_id, name)) >= 1) # same event with ExpectedException(Conflict): self.backend.update_container(account_id, name, mtime, dtime, 0, 0, 0, 0) res = self.backend.conn.zrangebylex('containers:%s' % account_id, '-', '+') self.assertEqual(len(res), 0) self.assertTrue( self.backend.conn.ttl('container:%s:%s' % (account_id, name)) >= 1) # old event with ExpectedException(Conflict): self.backend.update_container(account_id, name, old_mtime, 0, 0, 0, 0, 0) res = self.backend.conn.zrangebylex('containers:%s' % account_id, '-', '+') self.assertEqual(len(res), 0) self.assertTrue( self.backend.conn.ttl('container:%s:%s' % (account_id, name)) >= 1)
def test_handles_fails_to_complete_power_action_in_time(self): system_id = factory.make_name("system_id") context = {"context": factory.make_name("context")} driver = make_power_driver(wait_time=[0]) self.patch(driver, self.action_func) mock_query = self.patch(driver, "power_query") mock_query.return_value = self.bad_state method = getattr(driver, self.action) with ExpectedException(PowerError): yield method(system_id, context)