-
|
Hi there, congratulations for the great Just a quick question, does the library support some kind of mock Client for testing, similar to rusoto_mock for rusoto? I would like to unit-test the logic for parsing responses from the k8s API, but couldn't seem to find examples. Thanks, |
Beta Was this translation helpful? Give feedback.
Replies: 3 comments 5 replies
-
|
Hey there. Not at the moment unfortunately, it's something I want as well though, and it's more possible now that we have service/client distinction. Actually had a little bit of a go at creating a The problem; |
Beta Was this translation helpful? Give feedback.
-
|
For now, you can use |
Beta Was this translation helpful? Give feedback.
-
|
Thanks, it works! For what it's worth this is what I came up with. The code is not self-contained (also probably far from optimal), but I guess it may help somebody looking for more examples of the syntax. #[tokio::test(flavor="current_thread")]
async fn test_k8s() {
use std::{fs::File, io::BufReader};
use http::{Request, Response};
use hyper::Body;
use kube::{Client, Service, api::{Api, ListParams, ObjectList}};
use tower_test::{mock, mock::Handle};
use k8s_openapi::api::core::v1::{Node, Pod};
use super::{AsgInstance, eks::{ClientInfo, NodeInfo, PodInfo}};
async fn mock_k8s(handle: &mut Handle<Request<Body>, Response<Body>>) {
use kube::api::ListMeta;
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct ObjectListDef<T> where T: Clone,
{
pub metadata: ListMeta,
pub items: Vec<T>,
}
let (request, send) = handle.next_request().await.expect("Service not called");
let body = match request.uri().to_string().as_str() {
"/api/v1/nodes?" => {
let file = File::open("sample/nodes.json").unwrap();
let reader = BufReader::new(file);
let nodes: ObjectListDef<Node> = serde_json::from_reader(reader).unwrap();
serde_json::to_vec(&nodes).unwrap()
},
"/api/v1/namespaces/kube-system/pods?" => {
let file = File::open("sample/pods.json").unwrap();
let reader = BufReader::new(file);
let pods: ObjectListDef<Pod> = serde_json::from_reader(reader).unwrap();
serde_json::to_vec(&pods).unwrap()
},
_ => panic!("Unexpected API request {:?}", request),
};
send.send_response(
Response::builder()
.body(Body::from(body))
.unwrap());
}
let (mock_service, mut handle) = mock::pair::<Request<Body>, Response<Body>>();
let service = Service::new(mock_service);
let client = Client::new(service);
let c = client.clone();
let h = mock_k8s(&mut handle);
let (result, _) = futures::join!(c.get_count(), h);
let count = result.unwrap();
assert_eq!(count, 1);
let c = client.clone();
let h = mock_k8s(&mut handle);
let inst = AsgInstance{ id: String::from("i-f6ac1791b0771a1d9"), zone: String::from("us-east-1a") };
let (result, _) = futures::join!(c.get_node(&inst), h);
let node = result.unwrap();
assert_eq!(node.unwrap().name(), "ip-10-123-145-167.ec2.internal");
let c = client.clone();
let h = mock_k8s(&mut handle);
let n = Api::namespaced(c, "kube-system");
let p = ListParams::default();
let (result, _) = futures::join!(n.list(&p), h);
let pods: ObjectList<Pod> = result.unwrap();
let pod = pods.iter().next().unwrap().to_owned();
assert_eq!(pod.name(), "aws-node-g8m5d");
assert_eq!(pod.owner(), Some("DaemonSet"));
assert_eq!(pod.phase(), Some("Running"));
} |
Beta Was this translation helpful? Give feedback.
-
|
Hi Team Is there any update on this? The above suggested mock approach works for one time. I am not able to make it work for two api calls in the same test. Below is a sample function to demonstrate the problem. In function we are first checking if a kubernetes secret exist, if not then create it or else update it. use k8s_openapi::api::core::v1::Secret;
use kube::{
api::{Api, ObjectMeta, PostParams},
Error as KubeError,
};
use reqwest::StatusCode;
use std::collections::BTreeMap;
async fn set_k8_single_secret(
client: &Api<Secret>,
key: &str,
value: &str,
) -> Result<(), KubeError> {
match client.get(key).await {
Ok(mut secret) => {
let mut data: BTreeMap<String, String> = BTreeMap::new();
data.insert(key.to_string(), value.to_string());
secret.string_data = Some(data);
client.replace(key, &PostParams::default(), &secret).await
}
Err(KubeError::Api(e)) if e.code == StatusCode::NOT_FOUND => {
let mut data: BTreeMap<String, String> = BTreeMap::new();
data.insert(key.to_string(), value.to_string());
let metadata = ObjectMeta {
name: Some(key.to_string()),
..Default::default()
};
let secret = Secret {
metadata,
string_data: Some(data),
..Default::default()
};
client.create(&PostParams::default(), &secret).await
}
Err(e) => Err(e),
}
.map(|_| Ok(()))?
}Below is the test case for it. Just for clarity, I know problem is not with mod test {
use http::{Request, Response};
use k8s_openapi::api::core::v1::Secret;
use tower_test::mock;
use kube::{client::Body, Api, Client};
#[tokio::test]
async fn set_k8_single_secret_create() {
let key = "key";
let (mock_service, mut handle) = mock::pair::<Request<Body>, Response<Body>>();
handle.allow(2);
let spawned = tokio::spawn(async move {
let (request, send) = handle.next_request().await.expect("service not called");
let status_code = match request.method() {
&http::Method::GET
if format!("/api/v1/namespaces/default/secrets/{}", key)
== request.uri().to_string().as_str() =>
{
println!("received GET operation");
http::StatusCode::NOT_FOUND
}
&http::Method::POST
if "/api/v1/namespaces/default/secrets".to_string()
== request.uri().to_string() =>
{
println!("received CREATE operation");
http::StatusCode::OK
}
_ => panic!("unexpected url or method"),
};
send.send_response(
Response::builder()
.status(status_code)
.body(Body::from(serde_json::to_vec("{}").unwrap()))
.unwrap(),
);
});
let secrets: Api<Secret> = Api::default_namespaced(Client::new(mock_service, "default"));
assert!(crate::backend::tmp::set_k8_single_secret(&secrets, key, key).await.is_ok());
spawned.await.unwrap();
}
} |
Beta Was this translation helpful? Give feedback.
-
|
There are now some examples of using mocks handling multiple calls in controller-rs. There's also some general docs on it in https://kube.rs/controllers/testing/#unit-tests-with-mocks |
Beta Was this translation helpful? Give feedback.
-
|
Thanks for pointing it out. I did looked at it, but this still does not solves the case for me. I am actually trying to run two scenarios in single test. All these examples support single scenario only per test. In the above function which I am trying to test, in a single test there will be always two api calls first a Mocks example shown let us create an fake api server which can only serve one request within a single test. I need it to serve request twice during a single test. |
Beta Was this translation helpful? Give feedback.
-
|
The |
Beta Was this translation helpful? Give feedback.
-
|
I tried to modify my example as per the Below is the code for the same. use k8s_openapi::api::core::v1::Secret;
use kube::{
api::{Api,ObjectMeta, PostParams},
Error as KubeError,
};
use reqwest::StatusCode;
use std::collections::BTreeMap;
async fn set_k8_single_secret(client: &Api<Secret>, key: &str, value: &str) -> Result<(), KubeError> {
match client.get(key).await {
Ok(mut secret) => {
let mut data: BTreeMap<String, String> = BTreeMap::new();
data.insert(key.to_string(), value.to_string());
secret.string_data = Some(data);
client
.replace(key, &PostParams::default(), &secret)
.await
},
Err(KubeError::Api(e)) if e.code == StatusCode::NOT_FOUND => {
let mut data: BTreeMap<String, String> = BTreeMap::new();
data.insert(key.to_string(), value.to_string());
let metadata = ObjectMeta {
name: Some(key.to_string()),
..Default::default()
};
let secret = Secret {
metadata,
string_data: Some(data),
..Default::default()
};
client
.create(&PostParams::default(), &secret)
.await
},
Err(e) => Err(e),
}
.map(|_| Ok(()))?
}
#[cfg(test)]
mod test {
use super::set_k8_single_secret;
use http::{Request, Response};
use hyper::Error;
use k8s_openapi::api::core::v1::Secret;
use kube::{client::Body, Api, Client};
/// Scenarios we test for in ApiServerVerifier
pub enum Scenario {
SecretGetThenCreate(String),
}
type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
pub struct ApiServerVerifier(ApiServerHandle);
impl ApiServerVerifier {
/// Tests only get to run specific scenarios that has matching handlers
///
/// This setup makes it easy to handle multiple requests by chaining handlers together.
///
/// NB: If the controller is making more calls than we are handling in the scenario,
/// you then typically see a `KubeError(Service(Closed(())))` from the reconciler.
///
/// You should await the `JoinHandle` (with a timeout) from this function to ensure that the
/// scenario runs to completion (i.e. all expected calls were responded to),
/// using the timeout to catch missing api calls to Kubernetes.
pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
tokio::spawn(async move {
match scenario {
Scenario::SecretGetThenCreate(key) => {
self.set_k8_single_secret_create_get_operation(key.as_str())
.await
.unwrap()
.set_k8_single_secret_create_post_operation()
.await
}
}
.expect("scenario completed without errors");
})
}
async fn set_k8_single_secret_create_get_operation(
mut self,
key: &str,
) -> Result<Self, Error> {
let (request, send) = self.0.next_request().await.expect("service not called");
assert_eq!(request.method(), http::Method::GET);
assert_eq!(
request.uri().to_string(),
format!("/api/v1/namespaces/default/secrets/{}", key)
);
send.send_response(
Response::builder()
.status(http::StatusCode::NOT_FOUND)
.body(Body::from(serde_json::to_vec("{}").unwrap()))
.unwrap(),
);
Ok(self)
}
async fn set_k8_single_secret_create_post_operation(
mut self,
) -> Result<ApiServerVerifier, Error> {
let (request, send) = self.0.next_request().await.expect("service not called");
assert_eq!(request.method(), http::Method::POST);
assert_eq!(
request.uri().to_string(),
"/api/v1/namespaces/default/secrets?"
);
send.send_response(
Response::builder()
.status(http::StatusCode::OK)
.body(Body::from(serde_json::to_vec("{}").unwrap()))
.unwrap(),
);
Ok(self)
}
}
pub fn setup_api_server(namespace: &str) -> (Client, ApiServerVerifier) {
let (mock_service, handle) = tower_test::mock::pair::<Request<Body>, Response<Body>>();
let mock_client = Client::new(mock_service, namespace);
(mock_client, ApiServerVerifier(handle))
}
pub async fn timeout_after_1s(handle: tokio::task::JoinHandle<()>) {
tokio::time::timeout(std::time::Duration::from_secs(1), handle)
.await
.expect("timeout on mock apiserver")
.expect("scenario succeeded")
}
#[tokio::test]
async fn set_k8_single_secret_create() {
let key = "key";
let (client, fakeserver) = setup_api_server("default");
let scenario = Scenario::SecretGetThenCreate(key.to_string());
let mocksrv = fakeserver.run(scenario);
let secrets: Api<Secret> = Api::default_namespaced(client);
assert!(set_k8_single_secret(&secrets, key, key).await.is_ok());
timeout_after_1s(mocksrv).await
}
}Stacktrace for the same |
Beta Was this translation helpful? Give feedback.
For now, you can use
tower_test::mocklike this example: https://github.com/clux/kube-rs/pull/430/filesWe'd like to provide something more convenient.