You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: integration.rs
    path of file: ./repos/rivet/svc/pkg/mm-config/ops/version-get/tests
    
    the code of the file until where you have to start completion: use chirp_worker::prelude::*;
use proto::backend::{self};

use std::collections::HashSet;

struct TestVersion {
	region_id: Uuid,
	version_id: Uuid,
}

impl TestVersion {
	async fn create(ctx: &TestCtx, name: &str) -> Self {
		let version_id = Uuid::new_v4();

		let region_res = op!([ctx] faker_region {}).await.unwrap();
		let region_id = region_res.region_id.as_ref().unwrap().as_uuid();

		let game_res = op!([ctx] faker_game {
			..Default::default()
		})
		.await
		.unwrap();

		let build_res = op!([ctx] faker_build {
			game_id: game_res.game_id,
			image: backend::faker::Image::MmLobbyAutoReady as i32,
		})
		.await
		.unwrap();

		let config = backend::matchmaker::VersionConfig {
			lobby_groups: vec![backend::matchmaker::LobbyGroup {
				name_id: format!("test-{}", name),

				regions: vec![backend::matchmaker::lobby_group::Region {
					region_id: Some(region_id.into()),
					tier_name_id: util_mm::test::TIER_NAME_ID.to_owned(),
					idle_lobbies: None,
				}],
				max_players_normal: 8,
				max_players_direct: 10,
				max_players_party: 12,
				listable: true,
				taggable: false,
				allow_dynamic_max_players: false,

				runtime: Some(
					backend::matchmaker::lobby_runtime::Docker {
						build_id: build_res.build_id,
						args: Vec::new(),
						env_vars: vec![backend::matchmaker::lobby_runtime::EnvVar {
							key: "HELLO".into(),
							value: "world".into()
    
async fn single(ctx: TestCtx) {
	let version = TestVersion::create(&ctx, "a").await;

	let queries = vec![
		vec![version.version_id.into()],
		vec![
			version.version_id.into(),
			Uuid::new_v4().into(),
			Uuid::new_v4().into(),
		],
		vec![
			Uuid::new_v4().into(),
			version.version_id.into(),
			Uuid::new_v4().into(),
		],
	];
	for query in queries {
		let res = op!([ctx] mm_config_version_get {
			version_ids: query
		})
		.await
		.unwrap();
		let version_res = res.versions.first().expect("version not returned");
		let version_config_res = version_res.config.as_ref().unwrap();
		let lobby_group_res = version_config_res
			.lobby_groups
			.first()
			.expect("missing lobby group");
		assert_eq!("test-a", lobby_group_res.name_id);
		assert_eq!(8, lobby_group_res.max_players_normal);
		assert_eq!(10, lobby_group_res.max_players_direct);
		assert_eq!(12, lobby_group_res.max_players_party);

		let region_res = lobby_group_res.regions.first().expect("missing version");
		assert_eq!(
			version.region_id,
			region_res.region_id.as_ref().unwrap().as_uuid()
		);

		let runtime = lobby_group_res
			.runtime
			.as_ref()
			.unwrap()
			.runtime
			.as_ref()
			.unwrap();
		match runtime {
			backend::matchmaker::lobby_runtime::Runtime::Docker(runtime) => {
				let port_res = runtime.ports.first().expect("missing port");
				assert_eq!(1234, port_res.target_port.unwrap());

				let env_var_res = runtime.env_vars.first().expect("missing env var");
				assert_eq!("HELLO", env_var_res.key);
				assert_eq!("world", env_var_res.value);
			}
		}
	}
}