Raft coverage reasoning

handler.rs

    #[tracing::instrument(skip_all)]
    async fn create_store(
        &self,
        request: tonic::Request<CreateStore>,
    ) -> Result<tonic::Response<Unit>, tonic::Status> {
        let client_id = Self::client_id(&request);
        let params = request.into_inner();
        let raft_payload = self.raft.is_some().then(|| params.encode_to_vec());

        let mut predicates = params.predicates;
        if params.store_original {
            predicates.push(AHNLICH_AI_RESERVED_META_KEY.to_string());
        }
        let index_model: AiModel = params
            .index_model
            .try_into()
            .map_err(|_| AIProxyError::InputNotSpecified("Index model".to_string()))?;
        let query_model: AiModel = params
            .query_model
            .try_into()
            .map_err(|_| AIProxyError::InputNotSpecified("Query model".to_string()))?;
        let model: ModelDetails = SupportedModels::from(&index_model).to_model_details();
        let parent_id = tracer::span_to_trace_parent(tracing::Span::current());
        
        let db_client = self
            .db_client
            .as_ref()
            .ok_or_else(|| tonic::Status::failed_precondition("No DB client available"))?
            .clone();
        
        db_client
            .create_store(
                DbCreateStore {
                    store: params.store.clone(),
                    dimension: model.embedding_size.get() as u32,
                    create_predicates: predicates,
                    non_linear_indices: params.non_linear_indices,
                    error_if_exists: params.error_if_exists,
                },
                parent_id,
            )
            .await?;

        // Branch only at point of difference
        if let Some(raft) = &self.raft {
            let response = raft
                .client_write(ClientWriteRequest {
                    client_id,
                    request_id: self.next_request_id(),
                    command: AiCommand::CreateStore(raft_payload.unwrap()),
                })
                .await
                .map_err(map_raft_error)?;

            let _: Unit = Self::decode_ai_response(response.data.response, AiResponseKind::Unit)?;
            return Ok(tonic::Response::new(Unit {}));
        }

        let _ = self.store_handler.create_store(
            StoreName {
                value: params.store,
            },
            query_model,
            index_model,
            params.error_if_exists,
            params.store_original,
        )?;
        Ok(tonic::Response::new(Unit {}))
    }