feat: add support for Azurite docker

Refs: #108

Author: fulgas

Cargo.toml

@@ -15,6 +15,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 default = []
+azurite = []
 blocking = ["testcontainers/blocking"]
 watchdog = ["testcontainers/watchdog"]
 http_wait = ["testcontainers/http_wait"]
@@ -138,6 +139,10 @@ openssl-sys = { version = "0.9.103", features = ["vendored"] }
 native-tls = { version = "0.2.12", features = ["vendored"] }
 pulsar = "6.3"
 rqlite-rs = "0.6"
+azure_core = "0.21.0"
+azure_storage_blobs = "0.21.0"
+azure_storage = "0.21.0"
+base64 = "0.22.1"
 
 [[example]]
 name = "postgres"
@@ -178,3 +183,7 @@ required-features = ["rqlite"]
 [[example]]
 name = "zitadel"
 required-features = ["zitadel", "postgres"]
+
+[[example]]
+name = "azurite"
+required-features = ["azurite"]

examples/azurite.rs

@@ -0,0 +1,42 @@
+use azure_storage::{prelude::*, CloudLocation};
+use azure_storage_blobs::prelude::*;
+use futures::stream::StreamExt;
+use testcontainers::runners::AsyncRunner;
+use testcontainers_modules::azurite::{Azurite, BLOB_PORT};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error + 'static>> {
+    let container = Azurite::default().start().await?;
+    let container_client = ClientBuilder::with_location(
+        CloudLocation::Emulator {
+            address: "127.0.0.1".to_owned(),
+            port: container.get_host_port_ipv4(BLOB_PORT).await?,
+        },
+        StorageCredentials::emulator(),
+    )
+    .container_client("container-name");
+
+    container_client.create().await?;
+    let blob_client = container_client.blob_client("blob-name");
+    blob_client
+        .put_block_blob("hello world")
+        .content_type("text/plain")
+        .await?;
+    let mut result: Vec<u8> = vec![];
+
+    // The stream is composed of individual calls to the get blob endpoint
+    let mut stream = blob_client.get().into_stream();
+    while let Some(value) = stream.next().await {
+        let mut body = value?.data;
+        // For each response, we stream the body instead of collecting it all
+        // into one large allocation.
+        while let Some(value) = body.next().await {
+            let value = value?;
+            result.extend(&value);
+        }
+    }
+
+    println!("result: {:?}", result);
+
+    Ok(())
+}

src/azurite/mod.rs

@@ -0,0 +1,247 @@
+use std::{borrow::Cow, collections::BTreeMap};
+
+use testcontainers::{
+    core::{ContainerPort, WaitFor},
+    Image,
+};
+
+const NAME: &str = "mcr.microsoft.com/azure-storage/azurite";
+const TAG: &str = "3.34.0";
+
+/// Port that [`Azurite`] uses internally for blob storage.
+pub const BLOB_PORT: ContainerPort = ContainerPort::Tcp(10000);
+
+/// Port that [`Azurite`] uses internally for queue.
+pub const QUEUE_PORT: ContainerPort = ContainerPort::Tcp(10001);
+
+/// Port that [`Azurite`] uses internally for table.
+const TABLE_PORT: ContainerPort = ContainerPort::Tcp(10002);
+
+const AZURITE_ACCOUNTS: &str = "AZURITE_ACCOUNTS";
+
+/// Module to work with [`Azurite`] inside tests.
+///
+/// This module is based on the official [`Azurite docker image`].
+///
+/// # Example
+/// ```
+/// use testcontainers_modules::{
+///     azurite,
+///     azurite::{Azurite, BLOB_PORT},
+///     testcontainers::runners::SyncRunner,
+/// };
+///
+/// let azurite = Azurite::default().start().unwrap();
+/// let blob_port = azurite.get_host_port_ipv4(BLOB_PORT).unwrap();
+///
+/// // do something with the started azurite instance..
+/// ```
+///
+/// [`Azurite`]: https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azurite?toc=%2Fazure%2Fstorage%2Fblobs%2Ftoc.json&bc=%2Fazure%2Fstorage%2Fblobs%2Fbreadcrumb%2Ftoc.json&tabs=visual-studio%2Cblob-storage
+/// [`Azurite docker image`]: https://hub.docker.com/r/microsoft/azure-storage-azurite
+#[derive(Debug, Clone)]
+pub struct Azurite {
+    tag: String,
+    env_vars: BTreeMap<String, String>,
+    loose: bool,
+    skip_api_version_check: bool,
+    disable_telemetry: bool,
+}
+
+impl Default for Azurite {
+    fn default() -> Self {
+        Self {
+            tag: TAG.to_string(),
+            env_vars: BTreeMap::new(),
+            loose: false,
+            skip_api_version_check: false,
+            disable_telemetry: false,
+        }
+    }
+}
+impl Azurite {
+    /// Create a new azurite instance with the latest image
+    pub fn latest() -> Self {
+        Self {
+            tag: "latest".to_string(),
+            ..Self::default()
+        }
+    }
+
+    /// Overrides the image tag.
+    /// Check https://mcr.microsoft.com/v2/azure-storage/azurite/tags/list to see available tags.
+    pub fn with_tag(self, tag: String) -> Self {
+        Self { tag, ..self }
+    }
+
+    /// Sets the [Azurite accounts](https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azurite?toc=%2Fazure%2Fstorage%2Fblobs%2Ftoc.json&bc=%2Fazure%2Fstorage%2Fblobs%2Fbreadcrumb%2Ftoc.json&tabs=visual-studio%2Ctable-storage#custom-storage-accounts-and-keys) to be used by the instance.
+    ///
+    /// - Uses `AZURITE_ACCOUNTS` key is used to store the accounts in the environment variables.
+    /// - The format should be: `account1:key1[:key2];account2:key1[:key2];...`
+    pub fn with_accounts(self, accounts: String) -> Self {
+        let mut env_vars = self.env_vars;
+        env_vars.insert(AZURITE_ACCOUNTS.to_owned(), accounts);
+        Self { env_vars, ..self }
+    }
+
+    /// Disables strict mode
+    pub fn with_loose(self) -> Self {
+        Self {
+            loose: true,
+            ..self
+        }
+    }
+
+    /// Skips API version validation
+    pub fn with_skip_api_version_check(self) -> Self {
+        Self {
+            skip_api_version_check: true,
+            ..self
+        }
+    }
+
+    /// Disables telemetry data collection
+    pub fn with_disable_telemetry(self) -> Self {
+        Self {
+            disable_telemetry: true,
+            ..self
+        }
+    }
+}
+impl Image for Azurite {
+    fn name(&self) -> &str {
+        NAME
+    }
+
+    fn tag(&self) -> &str {
+        &self.tag
+    }
+
+    fn ready_conditions(&self) -> Vec<WaitFor> {
+        vec![WaitFor::message_on_stdout(
+            "Azurite Table service is successfully listening at http://0.0.0.0:10002",
+        )]
+    }
+
+    fn env_vars(
+        &self,
+    ) -> impl IntoIterator<Item = (impl Into<Cow<'_, str>>, impl Into<Cow<'_, str>>)> {
+        &self.env_vars
+    }
+
+    fn cmd(&self) -> impl IntoIterator<Item = impl Into<Cow<'_, str>>> {
+        let mut cmd = vec![
+            String::from("azurite"),
+            String::from("--blobHost"),
+            String::from("0.0.0.0"),
+            String::from("--queueHost"),
+            String::from("0.0.0.0"),
+            String::from("--tableHost"),
+            String::from("0.0.0.0"),
+        ];
+        if self.loose {
+            cmd.push(String::from("--loose"));
+        }
+        if self.skip_api_version_check {
+            cmd.push(String::from("--skipApiVersionCheck"));
+        }
+        if self.disable_telemetry {
+            cmd.push(String::from("--disableTelemetry"));
+        }
+        cmd
+    }
+
+    fn expose_ports(&self) -> &[ContainerPort] {
+        &[BLOB_PORT, QUEUE_PORT, TABLE_PORT]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use azure_storage::{prelude::*, CloudLocation};
+    use azure_storage_blobs::prelude::*;
+    use base64::{prelude::BASE64_STANDARD, Engine};
+
+    use crate::azurite::{Azurite, BLOB_PORT};
+
+    #[tokio::test]
+    async fn starts_with_async_runner() -> Result<(), Box<dyn std::error::Error + 'static>> {
+        use testcontainers::runners::AsyncRunner;
+        let azurite = Azurite::default();
+        azurite.start().await?;
+        Ok(())
+    }
+
+    #[test]
+    fn starts_with_sync_runner() -> Result<(), Box<dyn std::error::Error + 'static>> {
+        use testcontainers::runners::SyncRunner;
+        let azurite = Azurite::default();
+        azurite.start()?;
+        Ok(())
+    }
+
+    #[test]
+    fn starts_with_latest_tag() -> Result<(), Box<dyn std::error::Error + 'static>> {
+        use testcontainers::runners::SyncRunner;
+        let azurite = Azurite::latest().with_tag("latest".to_string());
+        azurite.start()?;
+        Ok(())
+    }
+
+    #[test]
+    fn starts_with_tag() -> Result<(), Box<dyn std::error::Error + 'static>> {
+        use testcontainers::runners::SyncRunner;
+        let azurite = Azurite::default().with_tag("latest".to_string());
+        azurite.start()?;
+        Ok(())
+    }
+
+    #[test]
+    fn starts_with_loose() -> Result<(), Box<dyn std::error::Error + 'static>> {
+        use testcontainers::runners::SyncRunner;
+        let azurite = Azurite::default().with_loose();
+        azurite.start()?;
+        Ok(())
+    }
+
+    #[test]
+    fn starts_with_with_skip_api_version_check() -> Result<(), Box<dyn std::error::Error + 'static>>
+    {
+        use testcontainers::runners::SyncRunner;
+        let azurite = Azurite::default().with_skip_api_version_check();
+        azurite.start()?;
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn starts_with_accounts() -> Result<(), Box<dyn std::error::Error + 'static>> {
+        use azure_core::auth::Secret;
+        use testcontainers::runners::AsyncRunner;
+
+        let data = b"key1";
+        let account_key = BASE64_STANDARD.encode(data);
+
+        let account_name = "account1";
+        let container = Azurite::default()
+            .with_accounts(format!("{}:{};", account_name, account_key))
+            .start()
+            .await?;
+
+        ClientBuilder::with_location(
+            CloudLocation::Custom {
+                account: account_name.to_string(),
+                uri: format!(
+                    "http://127.0.0.1:{}/{}",
+                    container.get_host_port_ipv4(BLOB_PORT).await?,
+                    account_name
+                ),
+            },
+            StorageCredentials::access_key(account_name, Secret::new(account_key)),
+        )
+        .container_client("container-name")
+        .create()
+        .await?;
+
+        Ok(())
+    }
+}

src/lib.rs

@@ -12,6 +12,12 @@
 #[cfg_attr(docsrs, doc(cfg(feature = "anvil")))]
 /// **Anvil** (local blockchain emulator for EVM-compatible development) testcontainer
 pub mod anvil;
+
+#[cfg(feature = "azurite")]
+#[cfg_attr(docsrs, doc(cfg(feature = "azurite")))]
+/// **Azurite** (azure storage emulator) testcontainer
+pub mod azurite;
+
 #[cfg(feature = "clickhouse")]
 #[cfg_attr(docsrs, doc(cfg(feature = "clickhouse")))]
 /// **Clickhouse** (analytics database) testcontainer