feat: add flags to specify repository from CLI

GuillaumeLagrange · GuillaumeLagrange · commit 8ae40f9127d0 · 2025-03-31T14:44:11.000+02:00
diff --git a/src/run/config.rs b/src/run/config.rs
@@ -2,6 +2,7 @@ use crate::prelude::*;
 use crate::run::instruments::Instruments;
 use url::Url;
 
+use crate::run::run_environment::RepositoryProvider;
 use crate::run::RunArgs;
 
 use super::RunnerMode;
@@ -10,6 +11,7 @@ use super::RunnerMode;
 pub struct Config {
     pub upload_url: Url,
     pub token: Option<String>,
+    pub repository_override: Option<RepositoryOverride>,
     pub working_directory: Option<String>,
     pub command: String,
 
@@ -20,6 +22,13 @@ pub struct Config {
     pub skip_setup: bool,
 }
 
+#[derive(Debug, PartialEq, Clone)]
+pub struct RepositoryOverride {
+    pub owner: String,
+    pub repository: String,
+    pub repository_provider: RepositoryProvider,
+}
+
 impl Config {
     pub fn set_token(&mut self, token: Option<String>) {
         self.token = token;
@@ -33,6 +42,7 @@ impl Config {
         Self {
             upload_url: Url::parse(DEFAULT_UPLOAD_URL).unwrap(),
             token: None,
+            repository_override: None,
             working_directory: None,
             command: "".into(),
             mode: RunnerMode::Instrumentation,
@@ -52,9 +62,22 @@ impl TryFrom<RunArgs> for Config {
         let raw_upload_url = args.upload_url.unwrap_or_else(|| DEFAULT_UPLOAD_URL.into());
         let upload_url = Url::parse(&raw_upload_url)
             .map_err(|e| anyhow!("Invalid upload URL: {}, {}", raw_upload_url, e))?;
+
         Ok(Self {
             upload_url,
             token: args.token,
+            repository_override: args
+                .repository
+                .map(|respository_and_owner| -> Result<RepositoryOverride> {
+                    let (owner, repository) =
+                        extract_owner_and_repository_from_arg(&respository_and_owner)?;
+                    Ok(RepositoryOverride {
+                        owner,
+                        repository,
+                        repository_provider: args.provider.unwrap_or_default(),
+                    })
+                })
+                .transpose()?,
             working_directory: args.working_directory,
             mode: args.mode,
             instruments,
@@ -65,6 +88,13 @@ impl TryFrom<RunArgs> for Config {
     }
 }
 
+fn extract_owner_and_repository_from_arg(owner_and_repository: &str) -> Result<(String, String)> {
+    let (owner, repository) = owner_and_repository
+        .split_once('/')
+        .context("Invalid owner/repository format")?;
+    Ok((owner.to_string(), repository.to_string()))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::run::instruments::MongoDBConfig;
@@ -76,6 +106,8 @@ mod tests {
         let config = Config::try_from(RunArgs {
             upload_url: None,
             token: None,
+            repository: None,
+            provider: None,
             working_directory: None,
             mode: RunnerMode::Instrumentation,
             instruments: vec![],
@@ -87,6 +119,7 @@ mod tests {
         .unwrap();
         assert_eq!(config.upload_url, Url::parse(DEFAULT_UPLOAD_URL).unwrap());
         assert_eq!(config.token, None);
+        assert_eq!(config.repository_override, None);
         assert_eq!(config.working_directory, None);
         assert_eq!(config.instruments, Instruments { mongodb: None });
         assert!(!config.skip_upload);
@@ -99,6 +132,8 @@ mod tests {
         let config = Config::try_from(RunArgs {
             upload_url: Some("https://example.com/upload".into()),
             token: Some("token".into()),
+            repository: Some("owner/repo".into()),
+            provider: Some(RepositoryProvider::GitLab),
             working_directory: Some("/tmp".into()),
             mode: RunnerMode::Instrumentation,
             instruments: vec!["mongodb".into()],
@@ -114,6 +149,14 @@ mod tests {
             Url::parse("https://example.com/upload").unwrap()
         );
         assert_eq!(config.token, Some("token".into()));
+        assert_eq!(
+            config.repository_override,
+            Some(RepositoryOverride {
+                owner: "owner".into(),
+                repository: "repo".into(),
+                repository_provider: RepositoryProvider::GitLab,
+            })
+        );
         assert_eq!(config.working_directory, Some("/tmp".into()));
         assert_eq!(
             config.instruments,
@@ -127,4 +170,18 @@ mod tests {
         assert!(config.skip_setup);
         assert_eq!(config.command, "cargo codspeed bench");
     }
+
+    #[test]
+    fn test_extract_owner_and_repository_from_arg() {
+        let owner_and_repository = "CodSpeedHQ/runner";
+        let (owner, repository) =
+            extract_owner_and_repository_from_arg(owner_and_repository).unwrap();
+        assert_eq!(owner, "CodSpeedHQ");
+        assert_eq!(repository, "runner");
+
+        let owner_and_repository = "CodSpeedHQ_runner";
+
+        let result = extract_owner_and_repository_from_arg(owner_and_repository);
+        assert!(result.is_err());
+    }
 }
diff --git a/src/run/mod.rs b/src/run/mod.rs
@@ -6,7 +6,7 @@ use crate::VERSION;
 use check_system::SystemInfo;
 use clap::{Args, ValueEnum};
 use instruments::mongo_tracer::{install_mongodb_tracer, MongoTracer};
-use run_environment::interfaces::RunEnvironment;
+use run_environment::interfaces::{RepositoryProvider, RunEnvironment};
 use runner::get_run_data;
 use serde::Serialize;
 
@@ -55,6 +55,19 @@ pub struct RunArgs {
     #[arg(long, env = "CODSPEED_TOKEN")]
     pub token: Option<String>,
 
+    /// The repository the benchmark is associated with, under the format `owner/repo`.
+    #[arg(short, long, env = "CODSPEED_REPOSITORY")]
+    pub repository: Option<String>,
+
+    /// The repository provider to use in case --repository is used. Defaults to github
+    #[arg(
+        long,
+        env = "CODSPEED_PROVIDER",
+        requires = "repository",
+        ignore_case = true
+    )]
+    pub provider: Option<RepositoryProvider>,
+
     /// The directory where the command will be executed.
     #[arg(long)]
     pub working_directory: Option<String>,
@@ -98,6 +111,8 @@ impl RunArgs {
         Self {
             upload_url: None,
             token: None,
+            repository: None,
+            provider: None,
             working_directory: None,
             mode: RunnerMode::Instrumentation,
             instruments: vec![],
@@ -186,3 +201,17 @@ pub async fn run(args: RunArgs, api_client: &CodSpeedAPIClient) -> Result<()> {
 
     Ok(())
 }
+
+// We have to implement this manually, because deriving the trait makes the CLI values `git-hub`
+// and `git-lab`
+impl clap::ValueEnum for RepositoryProvider {
+    fn value_variants<'a>() -> &'a [Self] {
+        &[Self::GitLab, Self::GitHub]
+    }
+    fn to_possible_value<'a>(&self) -> ::std::option::Option<clap::builder::PossibleValue> {
+        match self {
+            Self::GitLab => Some(clap::builder::PossibleValue::new("gitlab").aliases(["gl"])),
+            Self::GitHub => Some(clap::builder::PossibleValue::new("github").aliases(["gh"])),
+        }
+    }
+}
diff --git a/src/run/run_environment/buildkite/provider.rs b/src/run/run_environment/buildkite/provider.rs
@@ -61,6 +61,10 @@ impl TryFrom<&Config> for BuildkiteProvider {
             bail!("Token authentication is required for Buildkite");
         }
 
+        if config.repository_override.is_some() {
+            bail!("Specifying owner and repository from CLI is not supported for Buildkite");
+        }
+
         let is_pr = get_pr_number()?.is_some();
         let repository_url = get_env_variable("BUILDKITE_REPO")?;
         let GitRemote {
diff --git a/src/run/run_environment/github_actions/provider.rs b/src/run/run_environment/github_actions/provider.rs
@@ -47,7 +47,10 @@ lazy_static! {
 
 impl TryFrom<&Config> for GitHubActionsProvider {
     type Error = Error;
-    fn try_from(_config: &Config) -> Result<Self> {
+    fn try_from(config: &Config) -> Result<Self> {
+        if config.repository_override.is_some() {
+            bail!("Specifying owner and repository from CLI is not supported for Github Actions");
+        }
         let (owner, repository) = Self::get_owner_and_repository()?;
         let ref_ = get_env_variable("GITHUB_REF")?;
         let is_pr = PR_REF_REGEX.is_match(&ref_);
diff --git a/src/run/run_environment/gitlab_ci/provider.rs b/src/run/run_environment/gitlab_ci/provider.rs
@@ -28,7 +28,10 @@ pub struct GitLabCIProvider {
 
 impl TryFrom<&Config> for GitLabCIProvider {
     type Error = Error;
-    fn try_from(_config: &Config) -> Result<Self> {
+    fn try_from(config: &Config) -> Result<Self> {
+        if config.repository_override.is_some() {
+            bail!("Specifying owner and repository from CLI is not supported for GitLab CI");
+        }
         let owner = get_env_variable("CI_PROJECT_NAMESPACE")?;
         let repository = get_env_variable("CI_PROJECT_NAME")?;
 
diff --git a/src/run/run_environment/interfaces.rs b/src/run/run_environment/interfaces.rs
@@ -2,11 +2,12 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::BTreeMap;
 
-#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Default)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum RepositoryProvider {
-    GitLab,
+    #[default]
     GitHub,
+    GitLab,
 }
 
 #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
diff --git a/src/run/run_environment/local/provider.rs b/src/run/run_environment/local/provider.rs
@@ -3,6 +3,7 @@ use simplelog::SharedLogger;
 
 use crate::local_logger::get_local_logger;
 use crate::prelude::*;
+use crate::run::config::RepositoryOverride;
 use crate::run::helpers::{parse_git_remote, GitRemote};
 use crate::run::run_environment::{RunEnvironment, RunPart};
 use crate::run::{
@@ -14,54 +15,52 @@ use crate::run::{
     },
 };
 
+static FAKE_COMMIT_REF: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+
 #[derive(Debug)]
 pub struct LocalProvider {
     repository_provider: RepositoryProvider,
+    owner: String,
+    repository: String,
     pub ref_: String,
-    pub owner: String,
-    pub repository: String,
     pub head_ref: Option<String>,
     pub base_ref: Option<String>,
     pub event: RunEvent,
     pub repository_root_path: String,
 }
 
-impl LocalProvider {}
-
-fn extract_provider_owner_and_repository_from_remote_url(
-    remote_url: &str,
-) -> Result<(RepositoryProvider, String, String)> {
-    let GitRemote {
-        domain,
-        owner,
-        repository,
-    } = parse_git_remote(remote_url)?;
-    let repository_provider = match domain.as_str() {
-        "github.com" => RepositoryProvider::GitHub,
-        "gitlab.com" => RepositoryProvider::GitLab,
-        domain => bail!(
-            "Repository provider {} is not supported by CodSpeed",
-            domain
-        ),
-    };
-
-    Ok((
-        repository_provider,
-        owner.to_string(),
-        repository.to_string(),
-    ))
-}
-
 impl TryFrom<&Config> for LocalProvider {
     type Error = Error;
-    fn try_from(_config: &Config) -> Result<Self> {
-        let repository_root_path = match find_repository_root(&std::env::current_dir()?) {
-            Some(mut path) => {
-                // Add a trailing slash to the path
-                path.push("");
-                path.to_string_lossy().to_string()
-            },
-            None => bail!("Could not find repository root, please make sure you are running the command from inside a git repository"),
+    fn try_from(config: &Config) -> Result<Self> {
+        let current_dir = std::env::current_dir()?;
+
+        let repository_root_path = {
+            let Some(mut path) = find_repository_root(&current_dir) else {
+                // We are not in a git repository, use the repository_override with very minimal information
+                let RepositoryOverride {
+                    owner,
+                    repository,
+                    repository_provider,
+                } = config.repository_override.clone().context(
+                    "Could not find repository root and no repository was provided, \
+                    please make sure you are running the command from inside a git repository or provide repository with --repository flag",
+                )?;
+
+                return Ok(Self {
+                    repository_provider,
+                    ref_: FAKE_COMMIT_REF.to_string(),
+                    head_ref: None,
+                    base_ref: None,
+                    owner,
+                    repository,
+                    repository_root_path: current_dir.to_string_lossy().to_string(),
+                    event: RunEvent::Local,
+                });
+            };
+
+            // Add a trailing slash to the path
+            path.push("");
+            path.to_string_lossy().to_string()
         };
 
         let git_repository = Repository::open(repository_root_path.clone()).context(format!(
@@ -70,8 +69,17 @@ impl TryFrom<&Config> for LocalProvider {
         ))?;
 
         let remote = git_repository.find_remote("origin")?;
+
         let (repository_provider, owner, repository) =
-            extract_provider_owner_and_repository_from_remote_url(remote.url().unwrap())?;
+            if let Some(repo_override) = config.repository_override.clone() {
+                (
+                    repo_override.repository_provider,
+                    repo_override.owner,
+                    repo_override.repository,
+                )
+            } else {
+                extract_provider_owner_and_repository_from_remote_url(remote.url().unwrap())?
+            };
 
         let head = git_repository.head().context("Failed to get HEAD")?;
         let ref_ = head
@@ -139,6 +147,30 @@ impl RunEnvironmentProvider for LocalProvider {
     }
 }
 
+fn extract_provider_owner_and_repository_from_remote_url(
+    remote_url: &str,
+) -> Result<(RepositoryProvider, String, String)> {
+    let GitRemote {
+        domain,
+        owner,
+        repository,
+    } = parse_git_remote(remote_url)?;
+    let repository_provider = match domain.as_str() {
+        "github.com" => RepositoryProvider::GitHub,
+        "gitlab.com" => RepositoryProvider::GitLab,
+        domain => bail!(
+            "Repository provider {} is not supported by CodSpeed",
+            domain
+        ),
+    };
+
+    Ok((
+        repository_provider,
+        owner.to_string(),
+        repository.to_string(),
+    ))
+}
+
 #[cfg(test)]
 mod tests {
     // use crate::VERSION;
@@ -185,6 +217,11 @@ mod tests {
         }
     }
 
+    #[test]
+    fn fake_commit_hash_ref() {
+        assert_eq!(FAKE_COMMIT_REF.len(), 40);
+    }
+
     // TODO: uncomment later when we have a way to mock git repository
     // #[test]
     // fn test_provider_metadata() {
