Allow creation of common Collection operation results our of couchbase lib

[ankurmittal]

Hi,

Please allow the creation of common couchbase results out of couchbase crate so that it is easy to write unit tests

[chvck]

Hi @ankurmittal, this comment covers this issue and #356 - we recommend that users do not mock our types directly, and instead add an abstraction layer to their application which decouples the application from the SDK a bit and also provides a place to mock.

Some of our result types are non-trivial in their nature and it wouldn't be easy to actually expose a way to create them too.

[ankurmittal]

Hi, I tried it in our wrapper, but it will mean basically copying the content from result struct which will add to unnecessary latencies just to make it unit testable. What do you think?

[chvck]

I understand your issue here. We'd likely recommend that you introduce an interface layer between your wrapper and the SDK. Your mock type and the SDK type could then both implement that trait which would allow you to achieve what you're looking for I believe, without adding extra latencies. What do you think of that approach?

I'm hesitant to expose a way to create our result types because some (especially in the future when we add things like range scan) may wrap non-trivial types internally - such as types from our core crate which you wouldn't be able to create. We really don't want to end up in a place where some result types can be created, and others not. It'd already be somewhat difficult to expose a way to create our query result type.

[ankurmittal]

Can you give an example, let's say I want to mock get operation? What result type should my mock return?

[chvck]

I was thinking something along the lines of

trait GetResultTrait {
    fn content_as<V: DeserializeOwned>(&self) -> couchbase::error::Result<V>;
    fn cas(&self) -> u64;
}

impl GetResultTrait for couchbase::results::kv_results::GetResult {
    fn content_as<V: DeserializeOwned>(&self) -> couchbase::error::Result<V> {
        self.content_as()
    }

    fn cas(&self) -> u64 {
        self.cas()
    }
}

struct MockGetResult {
    data: Vec<u8>,
    cas: u64,
}

impl GetResultTrait for MockGetResult {
    fn content_as<V: DeserializeOwned>(&self) -> couchbase::error::Result<V> {
        Ok(serde_json::from_slice(&self.data).map_err(|e| {
            couchbase::error::Error::new(couchbase::error::ErrorKind::DecodingFailure(e.to_string()))
        })?)
    }

    fn cas(&self) -> u64 {
        self.cas
    }
}

This way your layer above the abstraction can get the data from the SDK result directly without an intermediary type but also be able to mock it. You could, of course, also translate any errors into your own types here too. Does that work?