Remaining refinements: tests, pre-release support, PR label strategy (#40)

* #4 Add tests for config, releases, and semver error cases

- error.rs: derive Clone + PartialEq to support test assertions
- models.rs: derive Clone on TagName and CreateReleaseRequest
- github_client.rs: extract GithubApi trait; move HTTP status/JSON
  handling from releases.rs into GithubClient's impl
- releases.rs: make Releases<C: GithubApi> generic; add 5 tests via
  MockGithubApi (request fields, error propagation, None on 404)
- config.rs: add 6 tests covering required fields, missing vars,
  invalid strategy, custom prefix/version, dry-run flag
- semver.rs: add 7 from_str error cases (empty, malformed, leading
  zeros, pre-release suffix)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* #2 Pre-release support (prerelease flag + identifier + counter)

- semver.rs: add PreRelease struct; update regex to parse -id.N suffix;
  add base_version(), with_pre_release(), bump_pre_release(),
  pre_release_matches(); increment() strips pre-release on all arms;
  get_version() includes pre-release suffix; 5 new tests
- config.rs: add prerelease (bool) and prerelease_identifier (String)
  fields read from INPUT_PRERELEASE / INPUT_PRERELEASE-IDENTIFIER
- releases.rs: pass config.prerelease into CreateReleaseRequest
- main.rs: NoRelease early-exit skipped when prerelease=true; version
  computation branches on prerelease — bumps counter if same identifier,
  otherwise applies strategy to base and starts at .1
- action.yaml: add prerelease and prerelease-identifier inputs

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* #1 Derive increment strategy from merged PR labels

- semver.rs: derive Clone on VersionIncrementStrategy
- models.rs: add Label and PullRequest models
- github_client.rs: add get_pr_for_commit to GithubApi trait;
  implement via GET /repos/{owner}/{repo}/commits/{sha}/pulls
- config.rs: add use_label_strategy, label_major, label_minor,
  label_patch, label_skip fields (all optional with sensible defaults)
- releases.rs: expose get_pr_for_commit; update MockGithubApi with
  pr_response field and with_pr_labels builder; add 2 new tests
- main.rs: add resolve_label_strategy (major > minor > skip > patch >
  fallback); run() fetches PR and resolves strategy when
  use_label_strategy=true; 6 new tests for label resolution
- action.yaml: add use-label-strategy, label-major, label-minor,
  label-patch, label-skip inputs

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dexwritescode

action.yaml

@@ -30,6 +30,34 @@ inputs:
     description: 'GitHub API host. Override for GitHub Enterprise (e.g. https://github.example.com/api/v3). Defaults to https://api.github.com.'
     required: false
     default: 'https://api.github.com'
+  prerelease:
+    description: 'Create a pre-release instead of a stable release.'
+    required: false
+    default: false
+  prerelease-identifier:
+    description: 'Pre-release identifier appended to the version (e.g. "beta" produces v1.2.0-beta.1). Defaults to rc.'
+    required: false
+    default: 'rc'
+  use-label-strategy:
+    description: 'Derive the increment strategy from PR labels instead of the version-increment-strategy input. Falls back to version-increment-strategy if no matching label is found.'
+    required: false
+    default: false
+  label-major:
+    description: 'PR label that triggers a major version bump.'
+    required: false
+    default: 'release:major'
+  label-minor:
+    description: 'PR label that triggers a minor version bump.'
+    required: false
+    default: 'release:minor'
+  label-patch:
+    description: 'PR label that triggers a patch version bump.'
+    required: false
+    default: 'release:patch'
+  label-skip:
+    description: 'PR label that skips release creation.'
+    required: false
+    default: 'release:skip'
 outputs:
   version:
     description: 'The version number that will be created'

src/config.rs

@@ -14,6 +14,13 @@ const BODY: &str = "INPUT_BODY";
 const GENERATE_RELEASE_NOTES: &str = "INPUT_GENERATE-RELEASE-NOTES";
 const DRY_RUN: &str = "INPUT_DRY-RUN";
 const INCREMENT_STRATEGY: &str = "INPUT_VERSION-INCREMENT-STRATEGY";
+const PRERELEASE: &str = "INPUT_PRERELEASE";
+const PRERELEASE_IDENTIFIER: &str = "INPUT_PRERELEASE-IDENTIFIER";
+const USE_LABEL_STRATEGY: &str = "INPUT_USE-LABEL-STRATEGY";
+const LABEL_MAJOR: &str = "INPUT_LABEL-MAJOR";
+const LABEL_MINOR: &str = "INPUT_LABEL-MINOR";
+const LABEL_PATCH: &str = "INPUT_LABEL-PATCH";
+const LABEL_SKIP: &str = "INPUT_LABEL-SKIP";
 
 #[derive(Debug)]
 pub struct Config {
@@ -29,6 +36,13 @@ pub struct Config {
     pub body: String,
     pub generate_release_notes: bool,
     pub dry_run: bool,
+    pub prerelease: bool,
+    pub prerelease_identifier: String,
+    pub use_label_strategy: bool,
+    pub label_major: String,
+    pub label_minor: String,
+    pub label_patch: String,
+    pub label_skip: String,
 }
 
 pub struct Token(pub String);
@@ -55,6 +69,13 @@ impl Config {
             body: get_body(),
             generate_release_notes: get_generate_release_notes()?,
             dry_run: is_dry_run()?,
+            prerelease: get_prerelease(),
+            prerelease_identifier: get_prerelease_identifier(),
+            use_label_strategy: get_use_label_strategy(),
+            label_major: get_label(LABEL_MAJOR, "release:major"),
+            label_minor: get_label(LABEL_MINOR, "release:minor"),
+            label_patch: get_label(LABEL_PATCH, "release:patch"),
+            label_skip: get_label(LABEL_SKIP, "release:skip"),
         })
     }
 
@@ -118,3 +139,123 @@ fn is_dry_run() -> Result<bool, ActionError> {
     let v = require_env(DRY_RUN)?;
     Ok(matches!(v.to_ascii_lowercase().as_str(), "true"))
 }
+
+fn get_prerelease() -> bool {
+    env::var(PRERELEASE).map_or(false, |v| matches!(v.to_ascii_lowercase().as_str(), "true"))
+}
+
+fn get_prerelease_identifier() -> String {
+    env::var(PRERELEASE_IDENTIFIER).unwrap_or_else(|_| "rc".to_string())
+}
+
+fn get_use_label_strategy() -> bool {
+    env::var(USE_LABEL_STRATEGY).map_or(false, |v| matches!(v.to_ascii_lowercase().as_str(), "true"))
+}
+
+fn get_label(var: &'static str, default: &str) -> String {
+    env::var(var).unwrap_or_else(|_| default.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+    fn set_required_env() {
+        std::env::set_var("GITHUB_REPOSITORY", "owner/repo");
+        std::env::set_var("GITHUB_OUTPUT", "/tmp/output");
+        std::env::set_var("GITHUB_TOKEN", "test-token");
+        std::env::set_var("GITHUB_SHA", "abc123");
+        std::env::set_var("INPUT_VERSION-INCREMENT-STRATEGY", "patch");
+        std::env::set_var("INPUT_GENERATE-RELEASE-NOTES", "true");
+        std::env::set_var("INPUT_DRY-RUN", "false");
+    }
+
+    fn clear_env() {
+        for var in &[
+            "GITHUB_REPOSITORY",
+            "GITHUB_OUTPUT",
+            "GITHUB_TOKEN",
+            "GITHUB_SHA",
+            "INPUT_VERSION-INCREMENT-STRATEGY",
+            "INPUT_GENERATE-RELEASE-NOTES",
+            "INPUT_DRY-RUN",
+            "INPUT_INITIAL-VERSION",
+            "INPUT_TAG-PREFIX",
+            "INPUT_BODY",
+            "INPUT_GITHUB-HOST",
+        ] {
+            std::env::remove_var(var);
+        }
+    }
+
+    #[test]
+    fn config_new_parses_required_fields() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        set_required_env();
+        let config = Config::new().unwrap();
+        assert_eq!(config.owner, "owner");
+        assert_eq!(config.repo, "repo");
+        assert_eq!(config.commitish, "abc123");
+        assert_eq!(config.github_output_path, "/tmp/output");
+        assert_eq!(config.tag_prefix, "v");
+        assert_eq!(config.default_version, "0.1.0");
+        assert_eq!(config.github_host, "https://api.github.com");
+        assert!(!config.dry_run);
+        assert!(config.generate_release_notes);
+        clear_env();
+    }
+
+    #[test]
+    fn config_missing_token_returns_error() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        set_required_env();
+        std::env::remove_var("GITHUB_TOKEN");
+        let err = Config::new().unwrap_err();
+        assert_eq!(err, ActionError::MissingEnv("GITHUB_TOKEN"));
+        clear_env();
+    }
+
+    #[test]
+    fn config_missing_repository_returns_error() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        set_required_env();
+        std::env::remove_var("GITHUB_REPOSITORY");
+        let err = Config::new().unwrap_err();
+        assert_eq!(err, ActionError::MissingEnv("GITHUB_REPOSITORY"));
+        clear_env();
+    }
+
+    #[test]
+    fn config_invalid_strategy_returns_error() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        set_required_env();
+        std::env::set_var("INPUT_VERSION-INCREMENT-STRATEGY", "bogus");
+        let err = Config::new().unwrap_err();
+        assert!(matches!(err, ActionError::InvalidStrategy(_)));
+        clear_env();
+    }
+
+    #[test]
+    fn config_custom_prefix_and_initial_version() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        set_required_env();
+        std::env::set_var("INPUT_TAG-PREFIX", "release-");
+        std::env::set_var("INPUT_INITIAL-VERSION", "2.0.0");
+        let config = Config::new().unwrap();
+        assert_eq!(config.get_default_tag(), "release-2.0.0");
+        clear_env();
+    }
+
+    #[test]
+    fn config_dry_run_parsed_correctly() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        set_required_env();
+        std::env::set_var("INPUT_DRY-RUN", "true");
+        let config = Config::new().unwrap();
+        assert!(config.dry_run);
+        clear_env();
+    }
+}

src/error.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum ActionError {
     MissingEnv(&'static str),
     InvalidStrategy(String),

src/github_client.rs

@@ -1,10 +1,18 @@
-use self::models::CreateReleaseRequest;
+use self::models::{CreateReleaseRequest, PullRequest, TagName};
+use crate::error::ActionError;
 use crate::Config;
 
 use reqwest::blocking::Client;
-use reqwest::blocking::Response;
 use reqwest::header;
-use reqwest::Error;
+use reqwest::StatusCode;
+
+pub mod models;
+
+pub trait GithubApi {
+    fn get_latest_release(&self) -> Result<Option<TagName>, ActionError>;
+    fn create_release(&self, request: &CreateReleaseRequest) -> Result<Option<TagName>, ActionError>;
+    fn get_pr_for_commit(&self, sha: &str) -> Result<Option<PullRequest>, ActionError>;
+}
 
 pub struct GithubClient {
     client: Client,
@@ -13,8 +21,6 @@ pub struct GithubClient {
     github_host: String,
 }
 
-pub mod models;
-
 impl GithubClient {
     pub fn new(config: &Config) -> GithubClient {
         let mut headers = header::HeaderMap::new();
@@ -41,25 +47,72 @@ impl GithubClient {
             github_host: config.github_host.clone(),
         }
     }
+}
 
+impl GithubApi for GithubClient {
     // GET /repos/{owner}/{repo}/releases/latest
-    pub fn get_latest_release(&self) -> Result<Response, Error> {
-        self.client
+    fn get_latest_release(&self) -> Result<Option<TagName>, ActionError> {
+        let response = self
+            .client
             .get(format!(
                 "{}/repos/{}/{}/releases/latest",
                 self.github_host, self.owner, self.repo
             ))
             .send()
+            .map_err(|e| ActionError::ApiError(e.to_string()))?;
+
+        match response.status() {
+            StatusCode::OK => response
+                .json()
+                .map_err(|e| ActionError::ApiError(e.to_string())),
+            StatusCode::NOT_FOUND => Ok(None),
+            StatusCode::UNAUTHORIZED => Err(ActionError::Unauthorized),
+            s => Err(ActionError::UnexpectedStatus(s.as_u16())),
+        }
     }
 
     // POST /repos/{owner}/{repo}/releases
-    pub fn create_release(&self, request: &CreateReleaseRequest) -> Result<Response, Error> {
-        self.client
+    fn create_release(&self, request: &CreateReleaseRequest) -> Result<Option<TagName>, ActionError> {
+        let response = self
+            .client
             .post(format!(
                 "{}/repos/{}/{}/releases",
                 self.github_host, self.owner, self.repo
             ))
             .json(request)
             .send()
+            .map_err(|e| ActionError::ApiError(e.to_string()))?;
+
+        match response.status() {
+            StatusCode::CREATED => response
+                .json()
+                .map_err(|e| ActionError::ApiError(e.to_string())),
+            StatusCode::UNAUTHORIZED => Err(ActionError::Unauthorized),
+            s => Err(ActionError::UnexpectedStatus(s.as_u16())),
+        }
+    }
+
+    // GET /repos/{owner}/{repo}/commits/{sha}/pulls
+    fn get_pr_for_commit(&self, sha: &str) -> Result<Option<PullRequest>, ActionError> {
+        let response = self
+            .client
+            .get(format!(
+                "{}/repos/{}/{}/commits/{}/pulls",
+                self.github_host, self.owner, self.repo, sha
+            ))
+            .send()
+            .map_err(|e| ActionError::ApiError(e.to_string()))?;
+
+        match response.status() {
+            StatusCode::OK => {
+                let prs: Vec<PullRequest> = response
+                    .json()
+                    .map_err(|e| ActionError::ApiError(e.to_string()))?;
+                Ok(prs.into_iter().next())
+            }
+            StatusCode::NOT_FOUND => Ok(None),
+            StatusCode::UNAUTHORIZED => Err(ActionError::Unauthorized),
+            s => Err(ActionError::UnexpectedStatus(s.as_u16())),
+        }
     }
 }

src/github_client/models.rs

@@ -1,12 +1,12 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct TagName {
     pub tag_name: String,
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Serialize, Debug, Clone)]
 pub struct CreateReleaseRequest {
     pub tag_name: String,
     pub target_commitish: String,
@@ -16,3 +16,13 @@ pub struct CreateReleaseRequest {
     pub prerelease: bool,
     pub generate_release_notes: bool,
 }
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Label {
+    pub name: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct PullRequest {
+    pub labels: Vec<Label>,
+}