diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..026d321 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,10 @@ +# Auto detect text files and normalize line endings to LF +* text=auto eol=lf + +# generated & committed +cdevents-sdk/src/generated/** linguist-generated=true gitlab-generated + +# Lock files (generated but should be diffed) +Cargo.lock linguist-generated=false +package-lock.json linguist-generated=false +bun.lockb binary diff --git a/.gitmodules b/.gitmodules index 51c52eb..03e28b8 100644 --- a/.gitmodules +++ b/.gitmodules @@ -9,3 +9,7 @@ path = cdevents-specs/spec-v0.4 url = https://github.com/cdevents/spec.git branch = spec-v0.4 +[submodule "cdevents-specs/spec-v0.5"] + path = cdevents-specs/spec-v0.5 + url = https://github.com/cdevents/spec.git + branch = spec-v0.5 diff --git a/.mise.toml b/.mise.toml index 7423e72..757161b 100644 --- a/.mise.toml +++ b/.mise.toml @@ -4,10 +4,10 @@ MISE_CARGO_BINSTALL = "true" [tools] "aqua:cargo-bins/cargo-binstall" = "1" -rust = { version = "1.89.0", profile = "minimal", components = "rustfmt,clippy" } # the rust tool stack (with cargo, fmt, clippy) to build source +rust = { version = "1.93.1", profile = "minimal", components = "rustfmt,clippy" } # the rust tool stack (with cargo, fmt, clippy) to build source "cargo:cargo-nextest" = "0.9" "cargo:cargo-hack" = "0.6" -"cargo:cargo-deny" = "0.16" +"cargo:cargo-deny" = "0.19" # "cargo:git-cliff" = "latest" "dprint" = "latest" @@ -70,6 +70,7 @@ run = [ # "git submodule add -f https://github.com/cdevents/spec.git cdevents-specs/main", # "git submodule add -f -b spec-v0.3 https://github.com/cdevents/spec.git cdevents-specs/spec-v0.3", # "git submodule add -f -b spec-v0.4 https://github.com/cdevents/spec.git cdevents-specs/spec-v0.4", +# "git submodule add -f -b spec-v0.5 https://github.com/cdevents/spec.git cdevents-specs/spec-v0.5", # "git submodule update -f --rebase -- cdevents-specs/main", # ] diff --git a/Cargo.toml b/Cargo.toml index dc6c19c..0a89d44 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,10 +5,6 @@ members = ["cdevents-sdk", "generator"] [workspace.package] edition = "2024" version = "0.2.1" -authors = [ - # The actual list of contributors can be retrieved from the git log - "The CDEvents Rust SDK Authors", -] license = "Apache-2.0" repository = "https://github.com/cdevents/sdk-rust" rust-version = "1.85" diff --git a/README.md b/README.md index 9f75100..c7252f8 100644 --- a/README.md +++ b/README.md @@ -9,25 +9,25 @@ The SDK can be used to create CDEvents and send them as CloudEvents, as well as Import the modules in your code ```toml -cdevents-sdk = "0.1" +cdevents-sdk = "0.3" ``` To send a CDEvent as CloudEvent: -```rust +````rust // from examples/pipelinerun_finished.rs use std::error::Error; -use cdevents_sdk::{CDEvent, Subject, spec_0_3_0::pipelinerun_finished, Content}; +use cdevents_sdk::{CDEvent, Subject, spec_0_5_0::pipelinerun_finished, Content}; use cloudevents::{Event, AttributesReader}; fn main() -> Result<(), Box> { let cdevent = CDEvent::from( Subject::from(pipelinerun_finished::Content{ errors: Some("pipelineErrors".into()), - outcome: Some("success".into()), + outcome: Some(pipelinerun_finished::ContentOutcome::Success), pipeline_name: Some("testPipeline".into()), - url: Some("https://dev.pipeline.run/url".into()) + uri: Some("https://dev.pipeline.run/url".try_into()?) }) .with_id("/dev/pipeline/run/1".try_into()?) .with_source("https://dev.pipeline.run/source".try_into()?) @@ -56,14 +56,15 @@ fn main() -> Result<(), Box> { assert_eq!(cdevent_expected, cdevent_extracted); Ok(()) } -``` +```` See the [CloudEvents](https://github.com/cloudevents/sdk-rust) docs as well. ## Features -- [x] support cdevents spec 0.3.0 +- [x] support cdevents spec 0.5.0 - [x] support cdevents spec 0.4.1 +- [x] support cdevents spec 0.3.0 - [ ] support of custom event - [ ] compile-time generation of type for custom event - [ ] runtime validation (download of jsonschemas & validation) diff --git a/cdevents-sdk/Cargo.toml b/cdevents-sdk/Cargo.toml index b9093a2..4b1c8ea 100644 --- a/cdevents-sdk/Cargo.toml +++ b/cdevents-sdk/Cargo.toml @@ -1,7 +1,6 @@ [package] name = "cdevents-sdk" version.workspace = true -authors.workspace = true edition.workspace = true license.workspace = true publish = true @@ -12,6 +11,7 @@ description = "A Rust SDK for CDEvents" [dependencies] cloudevents-sdk = { version = "0.9", optional = true, default-features = false } +enum_dispatch = "0.3" fluent-uri = { version = "0.4", features = ["serde"] } proptest = { version = "1", optional = true } proptest-derive = { version = "0.7", optional = true } diff --git a/cdevents-sdk/examples/pipelinerun_finished.rs b/cdevents-sdk/examples/pipelinerun_finished.rs index b4c2671..2fa385d 100644 --- a/cdevents-sdk/examples/pipelinerun_finished.rs +++ b/cdevents-sdk/examples/pipelinerun_finished.rs @@ -7,9 +7,9 @@ fn main() -> Result<(), Box> { let cdevent = CDEvent::from( Subject::from(pipelinerun_finished::Content{ errors: Some("pipelineErrors".into()), - outcome: Some("success".into()), + outcome: Some(pipelinerun_finished::ContentOutcome::Success), pipeline_name: Some("testPipeline".into()), - url: Some("https://dev.pipeline.run/url".into()) + uri: Some("https://dev.pipeline.run/url".try_into()?) }) .with_id("/dev/pipeline/run/1".try_into()?) .with_source("https://dev.pipeline.run/source".try_into()?) @@ -38,4 +38,3 @@ fn main() -> Result<(), Box> { assert_eq!(cdevent_expected, cdevent_extracted); Ok(()) } - diff --git a/cdevents-sdk/src/cdevent.rs b/cdevents-sdk/src/cdevent.rs index ad4b53c..25c1651 100644 --- a/cdevents-sdk/src/cdevent.rs +++ b/cdevents-sdk/src/cdevent.rs @@ -1,4 +1,4 @@ -use crate::{Context, Id, Subject, UriReference}; +use crate::{Context, ContextEnum, Id, Subject, UriReference}; use serde::{ de::{self, Deserializer, MapAccess, Visitor}, Deserialize, Serialize, @@ -8,7 +8,7 @@ use std::fmt; #[derive(Debug, Clone, Serialize, PartialEq, Eq)] #[serde(deny_unknown_fields)] pub struct CDEvent { - context: Context, + context: ContextEnum, subject: Subject, #[serde(rename = "customData", skip_serializing_if = "Option::is_none")] custom_data: Option, @@ -21,10 +21,8 @@ pub struct CDEvent { impl From for CDEvent { fn from(subject: Subject) -> Self { - let context = Context { - ty: subject.content().ty().into(), - ..Default::default() - }; + // TODO select context from subject version + let context = crate::new_context(subject.content().ty()); Self { context, subject, @@ -37,41 +35,41 @@ impl From for CDEvent { impl CDEvent { /// see pub fn version(&self) -> &str { - self.context.version.as_str() + self.context.version() } - pub fn with_version(mut self, v: T) -> Self where T: Into { - self.context.version = v.into(); - self - } + // pub fn with_version(mut self, v: T) -> Self where T: Into { + // self.context.with_version(v); + // self + // } /// see pub fn id(&self) -> &Id { - &self.context.id + self.context.id() } pub fn with_id(mut self, v: Id) -> Self { - self.context.id = v; + self.context = self.context.with_id(v); self } /// see pub fn source(&self) -> &UriReference { - &self.context.source + self.context.source() } pub fn with_source(mut self, v: UriReference) -> Self { - self.context.source = v; + self.context = self.context.with_source(v); self } /// see pub fn timestamp(&self) -> &time::OffsetDateTime { - &self.context.timestamp + self.context.timestamp() } pub fn with_timestamp(mut self, v: time::OffsetDateTime) -> Self { - self.context.timestamp = v; + self.context = self.context.with_timestamp(v); self } @@ -84,7 +82,7 @@ impl CDEvent { /// derived from subject.content pub fn ty(&self) -> &str { //self.subject.content().ty() - self.context.ty.as_str() + self.context.ty() } /// see @@ -127,6 +125,7 @@ impl<'de> Deserialize<'de> for CDEvent { struct CDEventVisitor; + // TODO remove dependencie to serde_json impl<'de> Visitor<'de> for CDEventVisitor { type Value = CDEvent; @@ -138,17 +137,17 @@ impl<'de> Deserialize<'de> for CDEvent { where V: MapAccess<'de>, { - let mut context: Option = None; + let mut context_json: Option = None; let mut subject_json: Option = None; let mut custom_data = None; let mut custom_data_content_type = None; while let Some(key) = map.next_key()? { match key { Field::Context => { - if context.is_some() { + if context_json.is_some() { return Err(de::Error::duplicate_field("context")); } - context = Some(map.next_value()?); + context_json = Some(map.next_value()?); } Field::Subject => { if subject_json.is_some() { @@ -170,11 +169,14 @@ impl<'de> Deserialize<'de> for CDEvent { } } } - let context = context.ok_or_else(|| de::Error::missing_field("context"))?; - let subject_json = - subject_json.ok_or_else(|| de::Error::missing_field("subject"))?; - let subject = - Subject::from_json(&context.ty, subject_json).map_err(de::Error::custom)?; + let context = { + let context_json = context_json.ok_or_else(|| de::Error::missing_field("context"))?; + ContextEnum::from_json(context_json).map_err(de::Error::custom)? + }; + let subject = { + let subject_json = subject_json.ok_or_else(|| de::Error::missing_field("subject"))?; + Subject::from_json(context.ty(), subject_json).map_err(de::Error::custom)? + }; Ok(CDEvent { context, @@ -221,4 +223,4 @@ mod tests { assert_eq!(s, actual); } } -} \ No newline at end of file +} diff --git a/cdevents-sdk/src/context.rs b/cdevents-sdk/src/context.rs index 1c7e32d..bc17cde 100644 --- a/cdevents-sdk/src/context.rs +++ b/cdevents-sdk/src/context.rs @@ -1,10 +1,139 @@ +#![allow(non_camel_case_types)] + use serde::{Deserialize, Serialize}; use crate::{Id, Uri, UriReference}; +#[enum_dispatch::enum_dispatch] +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(untagged, deny_unknown_fields)] +pub(crate) enum ContextEnum { + Context_0_5, + Context_0_4, + Context_0_3, +} + +#[enum_dispatch::enum_dispatch(ContextEnum)] +pub trait Context { + fn version(&self) -> &str; + fn id(&self) -> &Id; + fn with_id(self, v: Id) -> Self; + /// see + fn source(&self) -> &UriReference; + fn with_source(self, v: UriReference) -> Self; + /// see + fn timestamp(&self) -> &time::OffsetDateTime; + fn with_timestamp(self, v: time::OffsetDateTime) -> Self; + /// see + /// derived from subject.content + fn ty(&self) -> &str; +} + +impl ContextEnum { + pub fn from_json(json: serde_json::value::Value) -> Result { + let context = match json["specversion"].as_str().or_else(|| json["version"].as_str()) { + Some("0.3.0") => Self::Context_0_3(serde_json::from_value(json)?), + Some("0.4.0") | Some("0.4.1") => Self::Context_0_4(serde_json::from_value(json)?), + _ => Self::Context_0_5(serde_json::from_value(json)?), + }; + Ok(context) + } +} + +impl Default for ContextEnum { + fn default() -> Self { + Self::Context_0_5(Context_0_5 { + specversion: "0.5.0".into(), + id: Id::default(), + source: "/undef".try_into().expect("/undef is a valid uri-reference"), + ty: "dev.cdevents.undef.undef.0.0.0".into(), + timestamp: time::OffsetDateTime::now_utc(), + schema_uri: None, + chain_id: None, + links: None, + }) + } +} + #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] #[serde(deny_unknown_fields)] -pub(crate) struct Context { +pub(crate) struct Context_0_5 { + pub(crate) specversion: String, + pub(crate) id: Id, + pub(crate) source: UriReference, + #[serde(rename = "type")] + pub(crate) ty: String, + #[serde(with = "crate::serde::datetime")] + pub(crate) timestamp: time::OffsetDateTime, + #[serde(rename = "schemaUri", skip_serializing_if = "Option::is_none")] + pub(crate) schema_uri: Option, + #[serde(rename = "chainId", skip_serializing_if = "Option::is_none")] + pub(crate) chain_id: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub(crate) links: Option, +} + +impl Context_0_5 { + pub(crate) fn new(ty: String) -> Self { + Self{ + specversion: "0.5.0".into(), + id: Id::default(), + source: "/undef".try_into().expect("/undef is a valid uri-reference"), + ty, + timestamp: time::OffsetDateTime::now_utc(), + schema_uri: None, + chain_id: None, + links: None, + } + } +} + +impl Context for Context_0_5 { + fn version(&self) -> &str { + self.specversion.as_str() + } + + /// see + fn id(&self) -> &Id { + &self.id + } + + fn with_id(mut self, v: Id) -> Self { + self.id = v; + self + } + + /// see + fn source(&self) -> &UriReference { + &self.source + } + + fn with_source(mut self, v: UriReference) -> Self { + self.source = v; + self + } + + /// see + fn timestamp(&self) -> &time::OffsetDateTime { + &self.timestamp + } + + fn with_timestamp(mut self, v: time::OffsetDateTime) -> Self { + self.timestamp = v; + self + } + + /// see + /// derived from subject.content + fn ty(&self) -> &str { + //self.subject.content().ty() + self.ty.as_str() + } +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub(crate) struct Context_0_4 { pub(crate) version: String, pub(crate) id: Id, pub(crate) source: UriReference, @@ -20,13 +149,13 @@ pub(crate) struct Context { pub(crate) links: Option, } -impl Default for Context { - fn default() -> Self { - Self { - version: "0.3.0".into(), +impl Context_0_4 { + pub(crate) fn new(ty: String) -> Self { + Self{ + version: "0.4.1".into(), id: Id::default(), source: "/undef".try_into().expect("/undef is a valid uri-reference"), - ty: "dev.cdevents.undef.undef.0.0.0".into(), + ty, timestamp: time::OffsetDateTime::now_utc(), schema_uri: None, chain_id: None, @@ -34,3 +163,113 @@ impl Default for Context { } } } + +impl Context for Context_0_4 { + fn version(&self) -> &str { + self.version.as_str() + } + + /// see + fn id(&self) -> &Id { + &self.id + } + + fn with_id(mut self, v: Id) -> Self { + self.id = v; + self + } + + /// see + fn source(&self) -> &UriReference { + &self.source + } + + fn with_source(mut self, v: UriReference) -> Self { + self.source = v; + self + } + + /// see + fn timestamp(&self) -> &time::OffsetDateTime { + &self.timestamp + } + + fn with_timestamp(mut self, v: time::OffsetDateTime) -> Self { + self.timestamp = v; + self + } + + /// see + /// derived from subject.content + fn ty(&self) -> &str { + //self.subject.content().ty() + self.ty.as_str() + } +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(deny_unknown_fields)] +pub(crate) struct Context_0_3 { + pub(crate) version: String, + pub(crate) id: Id, + pub(crate) source: UriReference, + #[serde(rename = "type")] + pub(crate) ty: String, + #[serde(with = "crate::serde::datetime")] + pub(crate) timestamp: time::OffsetDateTime, +} + +impl Context_0_3 { + pub(crate) fn new(ty: String) -> Self { + Self{ + version: "0.3.0".into(), + id: Id::default(), + source: "/undef".try_into().expect("/undef is a valid uri-reference"), + ty, + timestamp: time::OffsetDateTime::now_utc(), + } + } +} + +impl Context for Context_0_3 { + fn version(&self) -> &str { + self.version.as_str() + } + + /// see + fn id(&self) -> &Id { + &self.id + } + + fn with_id(mut self, v: Id) -> Self { + self.id = v; + self + } + + /// see + fn source(&self) -> &UriReference { + &self.source + } + + fn with_source(mut self, v: UriReference) -> Self { + self.source = v; + self + } + + /// see + fn timestamp(&self) -> &time::OffsetDateTime { + &self.timestamp + } + + fn with_timestamp(mut self, v: time::OffsetDateTime) -> Self { + self.timestamp = v; + self + } + + /// see + /// derived from subject.content + fn ty(&self) -> &str { + //self.subject.content().ty() + self.ty.as_str() + } +} diff --git a/cdevents-sdk/src/generated/artifact_deleted_0_2_0.rs b/cdevents-sdk/src/generated/artifact_deleted_0_2_0.rs new file mode 100644 index 0000000..3ae4af6 --- /dev/null +++ b/cdevents-sdk/src/generated/artifact_deleted_0_2_0.rs @@ -0,0 +1,29 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "user", default, skip_serializing_if = "Option::is_none",)] + pub user: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/artifact_downloaded_0_2_0.rs b/cdevents-sdk/src/generated/artifact_downloaded_0_2_0.rs new file mode 100644 index 0000000..3ae4af6 --- /dev/null +++ b/cdevents-sdk/src/generated/artifact_downloaded_0_2_0.rs @@ -0,0 +1,29 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "user", default, skip_serializing_if = "Option::is_none",)] + pub user: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/artifact_packaged_0_3_0.rs b/cdevents-sdk/src/generated/artifact_packaged_0_3_0.rs new file mode 100644 index 0000000..8308a96 --- /dev/null +++ b/cdevents-sdk/src/generated/artifact_packaged_0_3_0.rs @@ -0,0 +1,49 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "change",)] + pub change: ContentChange, + #[serde(rename = "sbom", default, skip_serializing_if = "Option::is_none",)] + pub sbom: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentSbom { + #[serde(rename = "uri",)] + pub uri: crate::UriReference, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentChange { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/artifact_published_0_3_0.rs b/cdevents-sdk/src/generated/artifact_published_0_3_0.rs new file mode 100644 index 0000000..f31fcfa --- /dev/null +++ b/cdevents-sdk/src/generated/artifact_published_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "sbom", default, skip_serializing_if = "Option::is_none",)] + pub sbom: Option, + #[serde(rename = "user", default, skip_serializing_if = "Option::is_none",)] + pub user: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentSbom { + #[serde(rename = "uri",)] + pub uri: crate::UriReference, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/artifact_signed_0_3_0.rs b/cdevents-sdk/src/generated/artifact_signed_0_3_0.rs new file mode 100644 index 0000000..099735f --- /dev/null +++ b/cdevents-sdk/src/generated/artifact_signed_0_3_0.rs @@ -0,0 +1,29 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "signature",)] + pub signature: crate::NonEmptyString, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/branch_created_0_3_0.rs b/cdevents-sdk/src/generated/branch_created_0_3_0.rs new file mode 100644 index 0000000..99f44c3 --- /dev/null +++ b/cdevents-sdk/src/generated/branch_created_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "repository", default, skip_serializing_if = "Option::is_none",)] + pub repository: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentRepository { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/branch_deleted_0_3_0.rs b/cdevents-sdk/src/generated/branch_deleted_0_3_0.rs new file mode 100644 index 0000000..99f44c3 --- /dev/null +++ b/cdevents-sdk/src/generated/branch_deleted_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "repository", default, skip_serializing_if = "Option::is_none",)] + pub repository: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentRepository { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/build_finished_0_3_0.rs b/cdevents-sdk/src/generated/build_finished_0_3_0.rs new file mode 100644 index 0000000..ed7d960 --- /dev/null +++ b/cdevents-sdk/src/generated/build_finished_0_3_0.rs @@ -0,0 +1,29 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none",)] + pub artifact_id: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/build_queued_0_3_0.rs b/cdevents-sdk/src/generated/build_queued_0_3_0.rs new file mode 100644 index 0000000..c1162a8 --- /dev/null +++ b/cdevents-sdk/src/generated/build_queued_0_3_0.rs @@ -0,0 +1,27 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/build_started_0_3_0.rs b/cdevents-sdk/src/generated/build_started_0_3_0.rs new file mode 100644 index 0000000..c1162a8 --- /dev/null +++ b/cdevents-sdk/src/generated/build_started_0_3_0.rs @@ -0,0 +1,27 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/change_abandoned_0_3_0.rs b/cdevents-sdk/src/generated/change_abandoned_0_3_0.rs new file mode 100644 index 0000000..99f44c3 --- /dev/null +++ b/cdevents-sdk/src/generated/change_abandoned_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "repository", default, skip_serializing_if = "Option::is_none",)] + pub repository: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentRepository { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/change_created_0_4_0.rs b/cdevents-sdk/src/generated/change_created_0_4_0.rs new file mode 100644 index 0000000..f4500e7 --- /dev/null +++ b/cdevents-sdk/src/generated/change_created_0_4_0.rs @@ -0,0 +1,41 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "description", default, skip_serializing_if = "Option::is_none",)] + pub description: Option, + #[serde(rename = "repository", default, skip_serializing_if = "Option::is_none",)] + pub repository: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentRepository { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/change_merged_0_3_0.rs b/cdevents-sdk/src/generated/change_merged_0_3_0.rs new file mode 100644 index 0000000..99f44c3 --- /dev/null +++ b/cdevents-sdk/src/generated/change_merged_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "repository", default, skip_serializing_if = "Option::is_none",)] + pub repository: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentRepository { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/change_reviewed_0_3_0.rs b/cdevents-sdk/src/generated/change_reviewed_0_3_0.rs new file mode 100644 index 0000000..99f44c3 --- /dev/null +++ b/cdevents-sdk/src/generated/change_reviewed_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "repository", default, skip_serializing_if = "Option::is_none",)] + pub repository: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentRepository { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/change_updated_0_3_0.rs b/cdevents-sdk/src/generated/change_updated_0_3_0.rs new file mode 100644 index 0000000..99f44c3 --- /dev/null +++ b/cdevents-sdk/src/generated/change_updated_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "repository", default, skip_serializing_if = "Option::is_none",)] + pub repository: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentRepository { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/environment_created_0_3_0.rs b/cdevents-sdk/src/generated/environment_created_0_3_0.rs new file mode 100644 index 0000000..5798ae3 --- /dev/null +++ b/cdevents-sdk/src/generated/environment_created_0_3_0.rs @@ -0,0 +1,31 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/environment_deleted_0_3_0.rs b/cdevents-sdk/src/generated/environment_deleted_0_3_0.rs new file mode 100644 index 0000000..a10c7d6 --- /dev/null +++ b/cdevents-sdk/src/generated/environment_deleted_0_3_0.rs @@ -0,0 +1,29 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/environment_modified_0_3_0.rs b/cdevents-sdk/src/generated/environment_modified_0_3_0.rs new file mode 100644 index 0000000..5798ae3 --- /dev/null +++ b/cdevents-sdk/src/generated/environment_modified_0_3_0.rs @@ -0,0 +1,31 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/incident_detected_0_3_0.rs b/cdevents-sdk/src/generated/incident_detected_0_3_0.rs new file mode 100644 index 0000000..303f33b --- /dev/null +++ b/cdevents-sdk/src/generated/incident_detected_0_3_0.rs @@ -0,0 +1,55 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none",)] + pub artifact_id: Option, + #[serde(rename = "description", default, skip_serializing_if = "Option::is_none",)] + pub description: Option, + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "service", default, skip_serializing_if = "Option::is_none",)] + pub service: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentService { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/incident_reported_0_3_0.rs b/cdevents-sdk/src/generated/incident_reported_0_3_0.rs new file mode 100644 index 0000000..a4ac0c1 --- /dev/null +++ b/cdevents-sdk/src/generated/incident_reported_0_3_0.rs @@ -0,0 +1,57 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none",)] + pub artifact_id: Option, + #[serde(rename = "description", default, skip_serializing_if = "Option::is_none",)] + pub description: Option, + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "service", default, skip_serializing_if = "Option::is_none",)] + pub service: Option, + #[serde(rename = "ticketURI",)] + pub ticket_uri: crate::Uri, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentService { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/incident_resolved_0_3_0.rs b/cdevents-sdk/src/generated/incident_resolved_0_3_0.rs new file mode 100644 index 0000000..303f33b --- /dev/null +++ b/cdevents-sdk/src/generated/incident_resolved_0_3_0.rs @@ -0,0 +1,55 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none",)] + pub artifact_id: Option, + #[serde(rename = "description", default, skip_serializing_if = "Option::is_none",)] + pub description: Option, + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "service", default, skip_serializing_if = "Option::is_none",)] + pub service: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentService { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/mod.rs b/cdevents-sdk/src/generated/mod.rs index 3ac35a6..d3db9e3 100644 --- a/cdevents-sdk/src/generated/mod.rs +++ b/cdevents-sdk/src/generated/mod.rs @@ -3,137 +3,182 @@ use serde::{Serialize, Deserialize, de::Error}; +pub mod artifact_deleted_0_2_0; pub mod artifact_deleted_0_1_0; +pub mod artifact_downloaded_0_2_0; pub mod artifact_downloaded_0_1_0; +pub mod artifact_packaged_0_3_0; pub mod artifact_packaged_0_1_1; pub mod artifact_packaged_0_2_0; +pub mod artifact_published_0_3_0; pub mod artifact_published_0_1_1; pub mod artifact_published_0_2_0; +pub mod artifact_signed_0_3_0; pub mod artifact_signed_0_1_0; pub mod artifact_signed_0_2_0; +pub mod branch_created_0_3_0; pub mod branch_created_0_1_2; pub mod branch_created_0_2_0; +pub mod branch_deleted_0_3_0; pub mod branch_deleted_0_1_2; pub mod branch_deleted_0_2_0; +pub mod build_finished_0_3_0; pub mod build_finished_0_1_1; pub mod build_finished_0_2_0; +pub mod build_queued_0_3_0; pub mod build_queued_0_1_1; pub mod build_queued_0_2_0; +pub mod build_started_0_3_0; pub mod build_started_0_1_1; pub mod build_started_0_2_0; +pub mod change_abandoned_0_3_0; pub mod change_abandoned_0_1_2; pub mod change_abandoned_0_2_0; +pub mod change_created_0_4_0; pub mod change_created_0_1_2; pub mod change_created_0_3_0; +pub mod change_merged_0_3_0; pub mod change_merged_0_1_2; pub mod change_merged_0_2_0; +pub mod change_reviewed_0_3_0; pub mod change_reviewed_0_1_2; pub mod change_reviewed_0_2_0; +pub mod change_updated_0_3_0; pub mod change_updated_0_1_2; pub mod change_updated_0_2_0; +pub mod environment_created_0_3_0; pub mod environment_created_0_1_1; pub mod environment_created_0_2_0; +pub mod environment_deleted_0_3_0; pub mod environment_deleted_0_1_1; pub mod environment_deleted_0_2_0; +pub mod environment_modified_0_3_0; pub mod environment_modified_0_1_1; pub mod environment_modified_0_2_0; +pub mod incident_detected_0_3_0; pub mod incident_detected_0_1_0; pub mod incident_detected_0_2_0; +pub mod incident_reported_0_3_0; pub mod incident_reported_0_1_0; pub mod incident_reported_0_2_0; +pub mod incident_resolved_0_3_0; pub mod incident_resolved_0_1_0; pub mod incident_resolved_0_2_0; +pub mod pipelinerun_finished_0_3_0; pub mod pipelinerun_finished_0_1_1; pub mod pipelinerun_finished_0_2_0; +pub mod pipelinerun_queued_0_3_0; pub mod pipelinerun_queued_0_1_1; pub mod pipelinerun_queued_0_2_0; +pub mod pipelinerun_started_0_3_0; pub mod pipelinerun_started_0_1_1; pub mod pipelinerun_started_0_2_0; +pub mod repository_created_0_3_0; pub mod repository_created_0_1_1; pub mod repository_created_0_2_0; +pub mod repository_deleted_0_3_0; pub mod repository_deleted_0_1_1; pub mod repository_deleted_0_2_0; +pub mod repository_modified_0_3_0; pub mod repository_modified_0_1_1; pub mod repository_modified_0_2_0; +pub mod service_deployed_0_3_0; pub mod service_deployed_0_1_1; pub mod service_deployed_0_2_0; +pub mod service_published_0_3_0; pub mod service_published_0_1_1; pub mod service_published_0_2_0; +pub mod service_removed_0_3_0; pub mod service_removed_0_1_1; pub mod service_removed_0_2_0; +pub mod service_rolledback_0_3_0; pub mod service_rolledback_0_1_1; pub mod service_rolledback_0_2_0; +pub mod service_upgraded_0_3_0; pub mod service_upgraded_0_1_1; pub mod service_upgraded_0_2_0; +pub mod taskrun_finished_0_3_0; pub mod taskrun_finished_0_1_1; pub mod taskrun_finished_0_2_0; +pub mod taskrun_started_0_3_0; pub mod taskrun_started_0_1_1; pub mod taskrun_started_0_2_0; +pub mod testcaserun_finished_0_3_0; pub mod testcaserun_finished_0_1_0; pub mod testcaserun_finished_0_2_0; +pub mod testcaserun_queued_0_3_0; pub mod testcaserun_queued_0_1_0; pub mod testcaserun_queued_0_2_0; +pub mod testcaserun_skipped_0_2_0; pub mod testcaserun_skipped_0_1_0; +pub mod testcaserun_started_0_3_0; pub mod testcaserun_started_0_1_0; pub mod testcaserun_started_0_2_0; +pub mod testoutput_published_0_3_0; pub mod testoutput_published_0_1_0; pub mod testoutput_published_0_2_0; +pub mod testsuiterun_finished_0_3_0; pub mod testsuiterun_finished_0_1_0; pub mod testsuiterun_finished_0_2_0; +pub mod testsuiterun_queued_0_3_0; pub mod testsuiterun_queued_0_1_0; pub mod testsuiterun_queued_0_2_0; +pub mod testsuiterun_started_0_3_0; pub mod testsuiterun_started_0_1_0; pub mod testsuiterun_started_0_2_0; +pub mod ticket_closed_0_2_0; pub mod ticket_closed_0_1_0; +pub mod ticket_created_0_2_0; pub mod ticket_created_0_1_0; +pub mod ticket_updated_0_2_0; pub mod ticket_updated_0_1_0; pub mod latest { - pub use super::artifact_deleted_0_1_0 as artifact_deleted; - pub use super::artifact_downloaded_0_1_0 as artifact_downloaded; - pub use super::artifact_packaged_0_2_0 as artifact_packaged; - pub use super::artifact_published_0_2_0 as artifact_published; - pub use super::artifact_signed_0_2_0 as artifact_signed; - pub use super::branch_created_0_2_0 as branch_created; - pub use super::branch_deleted_0_2_0 as branch_deleted; - pub use super::build_finished_0_2_0 as build_finished; - pub use super::build_queued_0_2_0 as build_queued; - pub use super::build_started_0_2_0 as build_started; - pub use super::change_abandoned_0_2_0 as change_abandoned; - pub use super::change_created_0_3_0 as change_created; - pub use super::change_merged_0_2_0 as change_merged; - pub use super::change_reviewed_0_2_0 as change_reviewed; - pub use super::change_updated_0_2_0 as change_updated; - pub use super::environment_created_0_2_0 as environment_created; - pub use super::environment_deleted_0_2_0 as environment_deleted; - pub use super::environment_modified_0_2_0 as environment_modified; - pub use super::incident_detected_0_2_0 as incident_detected; - pub use super::incident_reported_0_2_0 as incident_reported; - pub use super::incident_resolved_0_2_0 as incident_resolved; - pub use super::pipelinerun_finished_0_2_0 as pipelinerun_finished; - pub use super::pipelinerun_queued_0_2_0 as pipelinerun_queued; - pub use super::pipelinerun_started_0_2_0 as pipelinerun_started; - pub use super::repository_created_0_2_0 as repository_created; - pub use super::repository_deleted_0_2_0 as repository_deleted; - pub use super::repository_modified_0_2_0 as repository_modified; - pub use super::service_deployed_0_2_0 as service_deployed; - pub use super::service_published_0_2_0 as service_published; - pub use super::service_removed_0_2_0 as service_removed; - pub use super::service_rolledback_0_2_0 as service_rolledback; - pub use super::service_upgraded_0_2_0 as service_upgraded; - pub use super::taskrun_finished_0_2_0 as taskrun_finished; - pub use super::taskrun_started_0_2_0 as taskrun_started; - pub use super::testcaserun_finished_0_2_0 as testcaserun_finished; - pub use super::testcaserun_queued_0_2_0 as testcaserun_queued; - pub use super::testcaserun_skipped_0_1_0 as testcaserun_skipped; - pub use super::testcaserun_started_0_2_0 as testcaserun_started; - pub use super::testoutput_published_0_2_0 as testoutput_published; - pub use super::testsuiterun_finished_0_2_0 as testsuiterun_finished; - pub use super::testsuiterun_queued_0_2_0 as testsuiterun_queued; - pub use super::testsuiterun_started_0_2_0 as testsuiterun_started; - pub use super::ticket_closed_0_1_0 as ticket_closed; - pub use super::ticket_created_0_1_0 as ticket_created; - pub use super::ticket_updated_0_1_0 as ticket_updated; + pub use super::artifact_deleted_0_2_0 as artifact_deleted; + pub use super::artifact_downloaded_0_2_0 as artifact_downloaded; + pub use super::artifact_packaged_0_3_0 as artifact_packaged; + pub use super::artifact_published_0_3_0 as artifact_published; + pub use super::artifact_signed_0_3_0 as artifact_signed; + pub use super::branch_created_0_3_0 as branch_created; + pub use super::branch_deleted_0_3_0 as branch_deleted; + pub use super::build_finished_0_3_0 as build_finished; + pub use super::build_queued_0_3_0 as build_queued; + pub use super::build_started_0_3_0 as build_started; + pub use super::change_abandoned_0_3_0 as change_abandoned; + pub use super::change_created_0_4_0 as change_created; + pub use super::change_merged_0_3_0 as change_merged; + pub use super::change_reviewed_0_3_0 as change_reviewed; + pub use super::change_updated_0_3_0 as change_updated; + pub use super::environment_created_0_3_0 as environment_created; + pub use super::environment_deleted_0_3_0 as environment_deleted; + pub use super::environment_modified_0_3_0 as environment_modified; + pub use super::incident_detected_0_3_0 as incident_detected; + pub use super::incident_reported_0_3_0 as incident_reported; + pub use super::incident_resolved_0_3_0 as incident_resolved; + pub use super::pipelinerun_finished_0_3_0 as pipelinerun_finished; + pub use super::pipelinerun_queued_0_3_0 as pipelinerun_queued; + pub use super::pipelinerun_started_0_3_0 as pipelinerun_started; + pub use super::repository_created_0_3_0 as repository_created; + pub use super::repository_deleted_0_3_0 as repository_deleted; + pub use super::repository_modified_0_3_0 as repository_modified; + pub use super::service_deployed_0_3_0 as service_deployed; + pub use super::service_published_0_3_0 as service_published; + pub use super::service_removed_0_3_0 as service_removed; + pub use super::service_rolledback_0_3_0 as service_rolledback; + pub use super::service_upgraded_0_3_0 as service_upgraded; + pub use super::taskrun_finished_0_3_0 as taskrun_finished; + pub use super::taskrun_started_0_3_0 as taskrun_started; + pub use super::testcaserun_finished_0_3_0 as testcaserun_finished; + pub use super::testcaserun_queued_0_3_0 as testcaserun_queued; + pub use super::testcaserun_skipped_0_2_0 as testcaserun_skipped; + pub use super::testcaserun_started_0_3_0 as testcaserun_started; + pub use super::testoutput_published_0_3_0 as testoutput_published; + pub use super::testsuiterun_finished_0_3_0 as testsuiterun_finished; + pub use super::testsuiterun_queued_0_3_0 as testsuiterun_queued; + pub use super::testsuiterun_started_0_3_0 as testsuiterun_started; + pub use super::ticket_closed_0_2_0 as ticket_closed; + pub use super::ticket_created_0_2_0 as ticket_created; + pub use super::ticket_updated_0_2_0 as ticket_updated; } pub mod spec_0_3_0 { pub use super::artifact_packaged_0_1_1 as artifact_packaged; @@ -223,178 +268,362 @@ pub mod spec_0_4_1 { pub use super::ticket_created_0_1_0 as ticket_created; pub use super::ticket_updated_0_1_0 as ticket_updated; } +pub mod spec_0_5_0 { + pub use super::artifact_deleted_0_2_0 as artifact_deleted; + pub use super::artifact_downloaded_0_2_0 as artifact_downloaded; + pub use super::artifact_packaged_0_3_0 as artifact_packaged; + pub use super::artifact_published_0_3_0 as artifact_published; + pub use super::artifact_signed_0_3_0 as artifact_signed; + pub use super::branch_created_0_3_0 as branch_created; + pub use super::branch_deleted_0_3_0 as branch_deleted; + pub use super::build_finished_0_3_0 as build_finished; + pub use super::build_queued_0_3_0 as build_queued; + pub use super::build_started_0_3_0 as build_started; + pub use super::change_abandoned_0_3_0 as change_abandoned; + pub use super::change_created_0_4_0 as change_created; + pub use super::change_merged_0_3_0 as change_merged; + pub use super::change_reviewed_0_3_0 as change_reviewed; + pub use super::change_updated_0_3_0 as change_updated; + pub use super::environment_created_0_3_0 as environment_created; + pub use super::environment_deleted_0_3_0 as environment_deleted; + pub use super::environment_modified_0_3_0 as environment_modified; + pub use super::incident_detected_0_3_0 as incident_detected; + pub use super::incident_reported_0_3_0 as incident_reported; + pub use super::incident_resolved_0_3_0 as incident_resolved; + pub use super::pipelinerun_finished_0_3_0 as pipelinerun_finished; + pub use super::pipelinerun_queued_0_3_0 as pipelinerun_queued; + pub use super::pipelinerun_started_0_3_0 as pipelinerun_started; + pub use super::repository_created_0_3_0 as repository_created; + pub use super::repository_deleted_0_3_0 as repository_deleted; + pub use super::repository_modified_0_3_0 as repository_modified; + pub use super::service_deployed_0_3_0 as service_deployed; + pub use super::service_published_0_3_0 as service_published; + pub use super::service_removed_0_3_0 as service_removed; + pub use super::service_rolledback_0_3_0 as service_rolledback; + pub use super::service_upgraded_0_3_0 as service_upgraded; + pub use super::taskrun_finished_0_3_0 as taskrun_finished; + pub use super::taskrun_started_0_3_0 as taskrun_started; + pub use super::testcaserun_finished_0_3_0 as testcaserun_finished; + pub use super::testcaserun_queued_0_3_0 as testcaserun_queued; + pub use super::testcaserun_skipped_0_2_0 as testcaserun_skipped; + pub use super::testcaserun_started_0_3_0 as testcaserun_started; + pub use super::testoutput_published_0_3_0 as testoutput_published; + pub use super::testsuiterun_finished_0_3_0 as testsuiterun_finished; + pub use super::testsuiterun_queued_0_3_0 as testsuiterun_queued; + pub use super::testsuiterun_started_0_3_0 as testsuiterun_started; + pub use super::ticket_closed_0_2_0 as ticket_closed; + pub use super::ticket_created_0_2_0 as ticket_created; + pub use super::ticket_updated_0_2_0 as ticket_updated; +} +pub mod spec_0_6_0_draft { + pub use super::artifact_deleted_0_2_0 as artifact_deleted; + pub use super::artifact_downloaded_0_2_0 as artifact_downloaded; + pub use super::artifact_packaged_0_3_0 as artifact_packaged; + pub use super::artifact_published_0_3_0 as artifact_published; + pub use super::artifact_signed_0_3_0 as artifact_signed; + pub use super::branch_created_0_3_0 as branch_created; + pub use super::branch_deleted_0_3_0 as branch_deleted; + pub use super::build_finished_0_3_0 as build_finished; + pub use super::build_queued_0_3_0 as build_queued; + pub use super::build_started_0_3_0 as build_started; + pub use super::change_abandoned_0_3_0 as change_abandoned; + pub use super::change_created_0_4_0 as change_created; + pub use super::change_merged_0_3_0 as change_merged; + pub use super::change_reviewed_0_3_0 as change_reviewed; + pub use super::change_updated_0_3_0 as change_updated; + pub use super::environment_created_0_3_0 as environment_created; + pub use super::environment_deleted_0_3_0 as environment_deleted; + pub use super::environment_modified_0_3_0 as environment_modified; + pub use super::incident_detected_0_3_0 as incident_detected; + pub use super::incident_reported_0_3_0 as incident_reported; + pub use super::incident_resolved_0_3_0 as incident_resolved; + pub use super::pipelinerun_finished_0_3_0 as pipelinerun_finished; + pub use super::pipelinerun_queued_0_3_0 as pipelinerun_queued; + pub use super::pipelinerun_started_0_3_0 as pipelinerun_started; + pub use super::repository_created_0_3_0 as repository_created; + pub use super::repository_deleted_0_3_0 as repository_deleted; + pub use super::repository_modified_0_3_0 as repository_modified; + pub use super::service_deployed_0_3_0 as service_deployed; + pub use super::service_published_0_3_0 as service_published; + pub use super::service_removed_0_3_0 as service_removed; + pub use super::service_rolledback_0_3_0 as service_rolledback; + pub use super::service_upgraded_0_3_0 as service_upgraded; + pub use super::taskrun_finished_0_3_0 as taskrun_finished; + pub use super::taskrun_started_0_3_0 as taskrun_started; + pub use super::testcaserun_finished_0_3_0 as testcaserun_finished; + pub use super::testcaserun_queued_0_3_0 as testcaserun_queued; + pub use super::testcaserun_skipped_0_2_0 as testcaserun_skipped; + pub use super::testcaserun_started_0_3_0 as testcaserun_started; + pub use super::testoutput_published_0_3_0 as testoutput_published; + pub use super::testsuiterun_finished_0_3_0 as testsuiterun_finished; + pub use super::testsuiterun_queued_0_3_0 as testsuiterun_queued; + pub use super::testsuiterun_started_0_3_0 as testsuiterun_started; + pub use super::ticket_closed_0_2_0 as ticket_closed; + pub use super::ticket_created_0_2_0 as ticket_created; + pub use super::ticket_updated_0_2_0 as ticket_updated; +} +pub const ARTIFACT_DELETED_0_2_0: &str = "dev.cdevents.artifact.deleted.0.2.0"; pub const ARTIFACT_DELETED_0_1_0: &str = "dev.cdevents.artifact.deleted.0.1.0"; +pub const ARTIFACT_DOWNLOADED_0_2_0: &str = "dev.cdevents.artifact.downloaded.0.2.0"; pub const ARTIFACT_DOWNLOADED_0_1_0: &str = "dev.cdevents.artifact.downloaded.0.1.0"; +pub const ARTIFACT_PACKAGED_0_3_0: &str = "dev.cdevents.artifact.packaged.0.3.0"; pub const ARTIFACT_PACKAGED_0_1_1: &str = "dev.cdevents.artifact.packaged.0.1.1"; pub const ARTIFACT_PACKAGED_0_2_0: &str = "dev.cdevents.artifact.packaged.0.2.0"; +pub const ARTIFACT_PUBLISHED_0_3_0: &str = "dev.cdevents.artifact.published.0.3.0"; pub const ARTIFACT_PUBLISHED_0_1_1: &str = "dev.cdevents.artifact.published.0.1.1"; pub const ARTIFACT_PUBLISHED_0_2_0: &str = "dev.cdevents.artifact.published.0.2.0"; +pub const ARTIFACT_SIGNED_0_3_0: &str = "dev.cdevents.artifact.signed.0.3.0"; pub const ARTIFACT_SIGNED_0_1_0: &str = "dev.cdevents.artifact.signed.0.1.0"; pub const ARTIFACT_SIGNED_0_2_0: &str = "dev.cdevents.artifact.signed.0.2.0"; +pub const BRANCH_CREATED_0_3_0: &str = "dev.cdevents.branch.created.0.3.0"; pub const BRANCH_CREATED_0_1_2: &str = "dev.cdevents.branch.created.0.1.2"; pub const BRANCH_CREATED_0_2_0: &str = "dev.cdevents.branch.created.0.2.0"; +pub const BRANCH_DELETED_0_3_0: &str = "dev.cdevents.branch.deleted.0.3.0"; pub const BRANCH_DELETED_0_1_2: &str = "dev.cdevents.branch.deleted.0.1.2"; pub const BRANCH_DELETED_0_2_0: &str = "dev.cdevents.branch.deleted.0.2.0"; +pub const BUILD_FINISHED_0_3_0: &str = "dev.cdevents.build.finished.0.3.0"; pub const BUILD_FINISHED_0_1_1: &str = "dev.cdevents.build.finished.0.1.1"; pub const BUILD_FINISHED_0_2_0: &str = "dev.cdevents.build.finished.0.2.0"; +pub const BUILD_QUEUED_0_3_0: &str = "dev.cdevents.build.queued.0.3.0"; pub const BUILD_QUEUED_0_1_1: &str = "dev.cdevents.build.queued.0.1.1"; pub const BUILD_QUEUED_0_2_0: &str = "dev.cdevents.build.queued.0.2.0"; +pub const BUILD_STARTED_0_3_0: &str = "dev.cdevents.build.started.0.3.0"; pub const BUILD_STARTED_0_1_1: &str = "dev.cdevents.build.started.0.1.1"; pub const BUILD_STARTED_0_2_0: &str = "dev.cdevents.build.started.0.2.0"; +pub const CHANGE_ABANDONED_0_3_0: &str = "dev.cdevents.change.abandoned.0.3.0"; pub const CHANGE_ABANDONED_0_1_2: &str = "dev.cdevents.change.abandoned.0.1.2"; pub const CHANGE_ABANDONED_0_2_0: &str = "dev.cdevents.change.abandoned.0.2.0"; +pub const CHANGE_CREATED_0_4_0: &str = "dev.cdevents.change.created.0.4.0"; pub const CHANGE_CREATED_0_1_2: &str = "dev.cdevents.change.created.0.1.2"; pub const CHANGE_CREATED_0_3_0: &str = "dev.cdevents.change.created.0.3.0"; +pub const CHANGE_MERGED_0_3_0: &str = "dev.cdevents.change.merged.0.3.0"; pub const CHANGE_MERGED_0_1_2: &str = "dev.cdevents.change.merged.0.1.2"; pub const CHANGE_MERGED_0_2_0: &str = "dev.cdevents.change.merged.0.2.0"; +pub const CHANGE_REVIEWED_0_3_0: &str = "dev.cdevents.change.reviewed.0.3.0"; pub const CHANGE_REVIEWED_0_1_2: &str = "dev.cdevents.change.reviewed.0.1.2"; pub const CHANGE_REVIEWED_0_2_0: &str = "dev.cdevents.change.reviewed.0.2.0"; +pub const CHANGE_UPDATED_0_3_0: &str = "dev.cdevents.change.updated.0.3.0"; pub const CHANGE_UPDATED_0_1_2: &str = "dev.cdevents.change.updated.0.1.2"; pub const CHANGE_UPDATED_0_2_0: &str = "dev.cdevents.change.updated.0.2.0"; +pub const ENVIRONMENT_CREATED_0_3_0: &str = "dev.cdevents.environment.created.0.3.0"; pub const ENVIRONMENT_CREATED_0_1_1: &str = "dev.cdevents.environment.created.0.1.1"; pub const ENVIRONMENT_CREATED_0_2_0: &str = "dev.cdevents.environment.created.0.2.0"; +pub const ENVIRONMENT_DELETED_0_3_0: &str = "dev.cdevents.environment.deleted.0.3.0"; pub const ENVIRONMENT_DELETED_0_1_1: &str = "dev.cdevents.environment.deleted.0.1.1"; pub const ENVIRONMENT_DELETED_0_2_0: &str = "dev.cdevents.environment.deleted.0.2.0"; +pub const ENVIRONMENT_MODIFIED_0_3_0: &str = "dev.cdevents.environment.modified.0.3.0"; pub const ENVIRONMENT_MODIFIED_0_1_1: &str = "dev.cdevents.environment.modified.0.1.1"; pub const ENVIRONMENT_MODIFIED_0_2_0: &str = "dev.cdevents.environment.modified.0.2.0"; +pub const INCIDENT_DETECTED_0_3_0: &str = "dev.cdevents.incident.detected.0.3.0"; pub const INCIDENT_DETECTED_0_1_0: &str = "dev.cdevents.incident.detected.0.1.0"; pub const INCIDENT_DETECTED_0_2_0: &str = "dev.cdevents.incident.detected.0.2.0"; +pub const INCIDENT_REPORTED_0_3_0: &str = "dev.cdevents.incident.reported.0.3.0"; pub const INCIDENT_REPORTED_0_1_0: &str = "dev.cdevents.incident.reported.0.1.0"; pub const INCIDENT_REPORTED_0_2_0: &str = "dev.cdevents.incident.reported.0.2.0"; +pub const INCIDENT_RESOLVED_0_3_0: &str = "dev.cdevents.incident.resolved.0.3.0"; pub const INCIDENT_RESOLVED_0_1_0: &str = "dev.cdevents.incident.resolved.0.1.0"; pub const INCIDENT_RESOLVED_0_2_0: &str = "dev.cdevents.incident.resolved.0.2.0"; +pub const PIPELINERUN_FINISHED_0_3_0: &str = "dev.cdevents.pipelinerun.finished.0.3.0"; pub const PIPELINERUN_FINISHED_0_1_1: &str = "dev.cdevents.pipelinerun.finished.0.1.1"; pub const PIPELINERUN_FINISHED_0_2_0: &str = "dev.cdevents.pipelinerun.finished.0.2.0"; +pub const PIPELINERUN_QUEUED_0_3_0: &str = "dev.cdevents.pipelinerun.queued.0.3.0"; pub const PIPELINERUN_QUEUED_0_1_1: &str = "dev.cdevents.pipelinerun.queued.0.1.1"; pub const PIPELINERUN_QUEUED_0_2_0: &str = "dev.cdevents.pipelinerun.queued.0.2.0"; +pub const PIPELINERUN_STARTED_0_3_0: &str = "dev.cdevents.pipelinerun.started.0.3.0"; pub const PIPELINERUN_STARTED_0_1_1: &str = "dev.cdevents.pipelinerun.started.0.1.1"; pub const PIPELINERUN_STARTED_0_2_0: &str = "dev.cdevents.pipelinerun.started.0.2.0"; +pub const REPOSITORY_CREATED_0_3_0: &str = "dev.cdevents.repository.created.0.3.0"; pub const REPOSITORY_CREATED_0_1_1: &str = "dev.cdevents.repository.created.0.1.1"; pub const REPOSITORY_CREATED_0_2_0: &str = "dev.cdevents.repository.created.0.2.0"; +pub const REPOSITORY_DELETED_0_3_0: &str = "dev.cdevents.repository.deleted.0.3.0"; pub const REPOSITORY_DELETED_0_1_1: &str = "dev.cdevents.repository.deleted.0.1.1"; pub const REPOSITORY_DELETED_0_2_0: &str = "dev.cdevents.repository.deleted.0.2.0"; +pub const REPOSITORY_MODIFIED_0_3_0: &str = "dev.cdevents.repository.modified.0.3.0"; pub const REPOSITORY_MODIFIED_0_1_1: &str = "dev.cdevents.repository.modified.0.1.1"; pub const REPOSITORY_MODIFIED_0_2_0: &str = "dev.cdevents.repository.modified.0.2.0"; +pub const SERVICE_DEPLOYED_0_3_0: &str = "dev.cdevents.service.deployed.0.3.0"; pub const SERVICE_DEPLOYED_0_1_1: &str = "dev.cdevents.service.deployed.0.1.1"; pub const SERVICE_DEPLOYED_0_2_0: &str = "dev.cdevents.service.deployed.0.2.0"; +pub const SERVICE_PUBLISHED_0_3_0: &str = "dev.cdevents.service.published.0.3.0"; pub const SERVICE_PUBLISHED_0_1_1: &str = "dev.cdevents.service.published.0.1.1"; pub const SERVICE_PUBLISHED_0_2_0: &str = "dev.cdevents.service.published.0.2.0"; +pub const SERVICE_REMOVED_0_3_0: &str = "dev.cdevents.service.removed.0.3.0"; pub const SERVICE_REMOVED_0_1_1: &str = "dev.cdevents.service.removed.0.1.1"; pub const SERVICE_REMOVED_0_2_0: &str = "dev.cdevents.service.removed.0.2.0"; +pub const SERVICE_ROLLEDBACK_0_3_0: &str = "dev.cdevents.service.rolledback.0.3.0"; pub const SERVICE_ROLLEDBACK_0_1_1: &str = "dev.cdevents.service.rolledback.0.1.1"; pub const SERVICE_ROLLEDBACK_0_2_0: &str = "dev.cdevents.service.rolledback.0.2.0"; +pub const SERVICE_UPGRADED_0_3_0: &str = "dev.cdevents.service.upgraded.0.3.0"; pub const SERVICE_UPGRADED_0_1_1: &str = "dev.cdevents.service.upgraded.0.1.1"; pub const SERVICE_UPGRADED_0_2_0: &str = "dev.cdevents.service.upgraded.0.2.0"; +pub const TASKRUN_FINISHED_0_3_0: &str = "dev.cdevents.taskrun.finished.0.3.0"; pub const TASKRUN_FINISHED_0_1_1: &str = "dev.cdevents.taskrun.finished.0.1.1"; pub const TASKRUN_FINISHED_0_2_0: &str = "dev.cdevents.taskrun.finished.0.2.0"; +pub const TASKRUN_STARTED_0_3_0: &str = "dev.cdevents.taskrun.started.0.3.0"; pub const TASKRUN_STARTED_0_1_1: &str = "dev.cdevents.taskrun.started.0.1.1"; pub const TASKRUN_STARTED_0_2_0: &str = "dev.cdevents.taskrun.started.0.2.0"; +pub const TESTCASERUN_FINISHED_0_3_0: &str = "dev.cdevents.testcaserun.finished.0.3.0"; pub const TESTCASERUN_FINISHED_0_1_0: &str = "dev.cdevents.testcaserun.finished.0.1.0"; pub const TESTCASERUN_FINISHED_0_2_0: &str = "dev.cdevents.testcaserun.finished.0.2.0"; +pub const TESTCASERUN_QUEUED_0_3_0: &str = "dev.cdevents.testcaserun.queued.0.3.0"; pub const TESTCASERUN_QUEUED_0_1_0: &str = "dev.cdevents.testcaserun.queued.0.1.0"; pub const TESTCASERUN_QUEUED_0_2_0: &str = "dev.cdevents.testcaserun.queued.0.2.0"; +pub const TESTCASERUN_SKIPPED_0_2_0: &str = "dev.cdevents.testcaserun.skipped.0.2.0"; pub const TESTCASERUN_SKIPPED_0_1_0: &str = "dev.cdevents.testcaserun.skipped.0.1.0"; +pub const TESTCASERUN_STARTED_0_3_0: &str = "dev.cdevents.testcaserun.started.0.3.0"; pub const TESTCASERUN_STARTED_0_1_0: &str = "dev.cdevents.testcaserun.started.0.1.0"; pub const TESTCASERUN_STARTED_0_2_0: &str = "dev.cdevents.testcaserun.started.0.2.0"; +pub const TESTOUTPUT_PUBLISHED_0_3_0: &str = "dev.cdevents.testoutput.published.0.3.0"; pub const TESTOUTPUT_PUBLISHED_0_1_0: &str = "dev.cdevents.testoutput.published.0.1.0"; pub const TESTOUTPUT_PUBLISHED_0_2_0: &str = "dev.cdevents.testoutput.published.0.2.0"; +pub const TESTSUITERUN_FINISHED_0_3_0: &str = "dev.cdevents.testsuiterun.finished.0.3.0"; pub const TESTSUITERUN_FINISHED_0_1_0: &str = "dev.cdevents.testsuiterun.finished.0.1.0"; pub const TESTSUITERUN_FINISHED_0_2_0: &str = "dev.cdevents.testsuiterun.finished.0.2.0"; +pub const TESTSUITERUN_QUEUED_0_3_0: &str = "dev.cdevents.testsuiterun.queued.0.3.0"; pub const TESTSUITERUN_QUEUED_0_1_0: &str = "dev.cdevents.testsuiterun.queued.0.1.0"; pub const TESTSUITERUN_QUEUED_0_2_0: &str = "dev.cdevents.testsuiterun.queued.0.2.0"; +pub const TESTSUITERUN_STARTED_0_3_0: &str = "dev.cdevents.testsuiterun.started.0.3.0"; pub const TESTSUITERUN_STARTED_0_1_0: &str = "dev.cdevents.testsuiterun.started.0.1.0"; pub const TESTSUITERUN_STARTED_0_2_0: &str = "dev.cdevents.testsuiterun.started.0.2.0"; +pub const TICKET_CLOSED_0_2_0: &str = "dev.cdevents.ticket.closed.0.2.0"; pub const TICKET_CLOSED_0_1_0: &str = "dev.cdevents.ticket.closed.0.1.0"; +pub const TICKET_CREATED_0_2_0: &str = "dev.cdevents.ticket.created.0.2.0"; pub const TICKET_CREATED_0_1_0: &str = "dev.cdevents.ticket.created.0.1.0"; +pub const TICKET_UPDATED_0_2_0: &str = "dev.cdevents.ticket.updated.0.2.0"; pub const TICKET_UPDATED_0_1_0: &str = "dev.cdevents.ticket.updated.0.1.0"; #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] #[serde(untagged)] // TODO how to use content of context.type as discriminator ? pub enum Content { + ArtifactDeleted020(artifact_deleted_0_2_0::Content), ArtifactDeleted010(artifact_deleted_0_1_0::Content), + ArtifactDownloaded020(artifact_downloaded_0_2_0::Content), ArtifactDownloaded010(artifact_downloaded_0_1_0::Content), + ArtifactPackaged030(artifact_packaged_0_3_0::Content), ArtifactPackaged011(artifact_packaged_0_1_1::Content), ArtifactPackaged020(artifact_packaged_0_2_0::Content), + ArtifactPublished030(artifact_published_0_3_0::Content), ArtifactPublished011(artifact_published_0_1_1::Content), ArtifactPublished020(artifact_published_0_2_0::Content), + ArtifactSigned030(artifact_signed_0_3_0::Content), ArtifactSigned010(artifact_signed_0_1_0::Content), ArtifactSigned020(artifact_signed_0_2_0::Content), + BranchCreated030(branch_created_0_3_0::Content), BranchCreated012(branch_created_0_1_2::Content), BranchCreated020(branch_created_0_2_0::Content), + BranchDeleted030(branch_deleted_0_3_0::Content), BranchDeleted012(branch_deleted_0_1_2::Content), BranchDeleted020(branch_deleted_0_2_0::Content), + BuildFinished030(build_finished_0_3_0::Content), BuildFinished011(build_finished_0_1_1::Content), BuildFinished020(build_finished_0_2_0::Content), + BuildQueued030(build_queued_0_3_0::Content), BuildQueued011(build_queued_0_1_1::Content), BuildQueued020(build_queued_0_2_0::Content), + BuildStarted030(build_started_0_3_0::Content), BuildStarted011(build_started_0_1_1::Content), BuildStarted020(build_started_0_2_0::Content), + ChangeAbandoned030(change_abandoned_0_3_0::Content), ChangeAbandoned012(change_abandoned_0_1_2::Content), ChangeAbandoned020(change_abandoned_0_2_0::Content), + ChangeCreated040(change_created_0_4_0::Content), ChangeCreated012(change_created_0_1_2::Content), ChangeCreated030(change_created_0_3_0::Content), + ChangeMerged030(change_merged_0_3_0::Content), ChangeMerged012(change_merged_0_1_2::Content), ChangeMerged020(change_merged_0_2_0::Content), + ChangeReviewed030(change_reviewed_0_3_0::Content), ChangeReviewed012(change_reviewed_0_1_2::Content), ChangeReviewed020(change_reviewed_0_2_0::Content), + ChangeUpdated030(change_updated_0_3_0::Content), ChangeUpdated012(change_updated_0_1_2::Content), ChangeUpdated020(change_updated_0_2_0::Content), + EnvironmentCreated030(environment_created_0_3_0::Content), EnvironmentCreated011(environment_created_0_1_1::Content), EnvironmentCreated020(environment_created_0_2_0::Content), + EnvironmentDeleted030(environment_deleted_0_3_0::Content), EnvironmentDeleted011(environment_deleted_0_1_1::Content), EnvironmentDeleted020(environment_deleted_0_2_0::Content), + EnvironmentModified030(environment_modified_0_3_0::Content), EnvironmentModified011(environment_modified_0_1_1::Content), EnvironmentModified020(environment_modified_0_2_0::Content), + IncidentDetected030(incident_detected_0_3_0::Content), IncidentDetected010(incident_detected_0_1_0::Content), IncidentDetected020(incident_detected_0_2_0::Content), + IncidentReported030(incident_reported_0_3_0::Content), IncidentReported010(incident_reported_0_1_0::Content), IncidentReported020(incident_reported_0_2_0::Content), + IncidentResolved030(incident_resolved_0_3_0::Content), IncidentResolved010(incident_resolved_0_1_0::Content), IncidentResolved020(incident_resolved_0_2_0::Content), + PipelinerunFinished030(pipelinerun_finished_0_3_0::Content), PipelinerunFinished011(pipelinerun_finished_0_1_1::Content), PipelinerunFinished020(pipelinerun_finished_0_2_0::Content), + PipelinerunQueued030(pipelinerun_queued_0_3_0::Content), PipelinerunQueued011(pipelinerun_queued_0_1_1::Content), PipelinerunQueued020(pipelinerun_queued_0_2_0::Content), + PipelinerunStarted030(pipelinerun_started_0_3_0::Content), PipelinerunStarted011(pipelinerun_started_0_1_1::Content), PipelinerunStarted020(pipelinerun_started_0_2_0::Content), + RepositoryCreated030(repository_created_0_3_0::Content), RepositoryCreated011(repository_created_0_1_1::Content), RepositoryCreated020(repository_created_0_2_0::Content), + RepositoryDeleted030(repository_deleted_0_3_0::Content), RepositoryDeleted011(repository_deleted_0_1_1::Content), RepositoryDeleted020(repository_deleted_0_2_0::Content), + RepositoryModified030(repository_modified_0_3_0::Content), RepositoryModified011(repository_modified_0_1_1::Content), RepositoryModified020(repository_modified_0_2_0::Content), + ServiceDeployed030(service_deployed_0_3_0::Content), ServiceDeployed011(service_deployed_0_1_1::Content), ServiceDeployed020(service_deployed_0_2_0::Content), + ServicePublished030(service_published_0_3_0::Content), ServicePublished011(service_published_0_1_1::Content), ServicePublished020(service_published_0_2_0::Content), + ServiceRemoved030(service_removed_0_3_0::Content), ServiceRemoved011(service_removed_0_1_1::Content), ServiceRemoved020(service_removed_0_2_0::Content), + ServiceRolledback030(service_rolledback_0_3_0::Content), ServiceRolledback011(service_rolledback_0_1_1::Content), ServiceRolledback020(service_rolledback_0_2_0::Content), + ServiceUpgraded030(service_upgraded_0_3_0::Content), ServiceUpgraded011(service_upgraded_0_1_1::Content), ServiceUpgraded020(service_upgraded_0_2_0::Content), + TaskrunFinished030(taskrun_finished_0_3_0::Content), TaskrunFinished011(taskrun_finished_0_1_1::Content), TaskrunFinished020(taskrun_finished_0_2_0::Content), + TaskrunStarted030(taskrun_started_0_3_0::Content), TaskrunStarted011(taskrun_started_0_1_1::Content), TaskrunStarted020(taskrun_started_0_2_0::Content), + TestcaserunFinished030(testcaserun_finished_0_3_0::Content), TestcaserunFinished010(testcaserun_finished_0_1_0::Content), TestcaserunFinished020(testcaserun_finished_0_2_0::Content), + TestcaserunQueued030(testcaserun_queued_0_3_0::Content), TestcaserunQueued010(testcaserun_queued_0_1_0::Content), TestcaserunQueued020(testcaserun_queued_0_2_0::Content), + TestcaserunSkipped020(testcaserun_skipped_0_2_0::Content), TestcaserunSkipped010(testcaserun_skipped_0_1_0::Content), + TestcaserunStarted030(testcaserun_started_0_3_0::Content), TestcaserunStarted010(testcaserun_started_0_1_0::Content), TestcaserunStarted020(testcaserun_started_0_2_0::Content), + TestoutputPublished030(testoutput_published_0_3_0::Content), TestoutputPublished010(testoutput_published_0_1_0::Content), TestoutputPublished020(testoutput_published_0_2_0::Content), + TestsuiterunFinished030(testsuiterun_finished_0_3_0::Content), TestsuiterunFinished010(testsuiterun_finished_0_1_0::Content), TestsuiterunFinished020(testsuiterun_finished_0_2_0::Content), + TestsuiterunQueued030(testsuiterun_queued_0_3_0::Content), TestsuiterunQueued010(testsuiterun_queued_0_1_0::Content), TestsuiterunQueued020(testsuiterun_queued_0_2_0::Content), + TestsuiterunStarted030(testsuiterun_started_0_3_0::Content), TestsuiterunStarted010(testsuiterun_started_0_1_0::Content), TestsuiterunStarted020(testsuiterun_started_0_2_0::Content), + TicketClosed020(ticket_closed_0_2_0::Content), TicketClosed010(ticket_closed_0_1_0::Content), + TicketCreated020(ticket_created_0_2_0::Content), TicketCreated010(ticket_created_0_1_0::Content), + TicketUpdated020(ticket_updated_0_2_0::Content), TicketUpdated010(ticket_updated_0_1_0::Content), Custom{ #[serde(skip)] @@ -407,14 +636,26 @@ pub enum Content { impl Content { pub fn from_json(ty: &str, json: serde_json::Value) -> Result{ match ty { + ARTIFACT_DELETED_0_2_0 => { + let variant: artifact_deleted_0_2_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ARTIFACT_DELETED_0_1_0 => { let variant: artifact_deleted_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + ARTIFACT_DOWNLOADED_0_2_0 => { + let variant: artifact_downloaded_0_2_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ARTIFACT_DOWNLOADED_0_1_0 => { let variant: artifact_downloaded_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + ARTIFACT_PACKAGED_0_3_0 => { + let variant: artifact_packaged_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ARTIFACT_PACKAGED_0_1_1 => { let variant: artifact_packaged_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -423,6 +664,10 @@ impl Content { let variant: artifact_packaged_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + ARTIFACT_PUBLISHED_0_3_0 => { + let variant: artifact_published_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ARTIFACT_PUBLISHED_0_1_1 => { let variant: artifact_published_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -431,6 +676,10 @@ impl Content { let variant: artifact_published_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + ARTIFACT_SIGNED_0_3_0 => { + let variant: artifact_signed_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ARTIFACT_SIGNED_0_1_0 => { let variant: artifact_signed_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -439,6 +688,10 @@ impl Content { let variant: artifact_signed_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + BRANCH_CREATED_0_3_0 => { + let variant: branch_created_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, BRANCH_CREATED_0_1_2 => { let variant: branch_created_0_1_2::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -447,6 +700,10 @@ impl Content { let variant: branch_created_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + BRANCH_DELETED_0_3_0 => { + let variant: branch_deleted_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, BRANCH_DELETED_0_1_2 => { let variant: branch_deleted_0_1_2::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -455,6 +712,10 @@ impl Content { let variant: branch_deleted_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + BUILD_FINISHED_0_3_0 => { + let variant: build_finished_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, BUILD_FINISHED_0_1_1 => { let variant: build_finished_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -463,6 +724,10 @@ impl Content { let variant: build_finished_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + BUILD_QUEUED_0_3_0 => { + let variant: build_queued_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, BUILD_QUEUED_0_1_1 => { let variant: build_queued_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -471,6 +736,10 @@ impl Content { let variant: build_queued_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + BUILD_STARTED_0_3_0 => { + let variant: build_started_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, BUILD_STARTED_0_1_1 => { let variant: build_started_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -479,6 +748,10 @@ impl Content { let variant: build_started_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + CHANGE_ABANDONED_0_3_0 => { + let variant: change_abandoned_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, CHANGE_ABANDONED_0_1_2 => { let variant: change_abandoned_0_1_2::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -487,6 +760,10 @@ impl Content { let variant: change_abandoned_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + CHANGE_CREATED_0_4_0 => { + let variant: change_created_0_4_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, CHANGE_CREATED_0_1_2 => { let variant: change_created_0_1_2::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -495,6 +772,10 @@ impl Content { let variant: change_created_0_3_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + CHANGE_MERGED_0_3_0 => { + let variant: change_merged_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, CHANGE_MERGED_0_1_2 => { let variant: change_merged_0_1_2::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -503,6 +784,10 @@ impl Content { let variant: change_merged_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + CHANGE_REVIEWED_0_3_0 => { + let variant: change_reviewed_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, CHANGE_REVIEWED_0_1_2 => { let variant: change_reviewed_0_1_2::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -511,6 +796,10 @@ impl Content { let variant: change_reviewed_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + CHANGE_UPDATED_0_3_0 => { + let variant: change_updated_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, CHANGE_UPDATED_0_1_2 => { let variant: change_updated_0_1_2::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -519,6 +808,10 @@ impl Content { let variant: change_updated_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + ENVIRONMENT_CREATED_0_3_0 => { + let variant: environment_created_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ENVIRONMENT_CREATED_0_1_1 => { let variant: environment_created_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -527,6 +820,10 @@ impl Content { let variant: environment_created_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + ENVIRONMENT_DELETED_0_3_0 => { + let variant: environment_deleted_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ENVIRONMENT_DELETED_0_1_1 => { let variant: environment_deleted_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -535,6 +832,10 @@ impl Content { let variant: environment_deleted_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + ENVIRONMENT_MODIFIED_0_3_0 => { + let variant: environment_modified_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, ENVIRONMENT_MODIFIED_0_1_1 => { let variant: environment_modified_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -543,6 +844,10 @@ impl Content { let variant: environment_modified_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + INCIDENT_DETECTED_0_3_0 => { + let variant: incident_detected_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, INCIDENT_DETECTED_0_1_0 => { let variant: incident_detected_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -551,6 +856,10 @@ impl Content { let variant: incident_detected_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + INCIDENT_REPORTED_0_3_0 => { + let variant: incident_reported_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, INCIDENT_REPORTED_0_1_0 => { let variant: incident_reported_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -559,6 +868,10 @@ impl Content { let variant: incident_reported_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + INCIDENT_RESOLVED_0_3_0 => { + let variant: incident_resolved_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, INCIDENT_RESOLVED_0_1_0 => { let variant: incident_resolved_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -567,6 +880,10 @@ impl Content { let variant: incident_resolved_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + PIPELINERUN_FINISHED_0_3_0 => { + let variant: pipelinerun_finished_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, PIPELINERUN_FINISHED_0_1_1 => { let variant: pipelinerun_finished_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -575,6 +892,10 @@ impl Content { let variant: pipelinerun_finished_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + PIPELINERUN_QUEUED_0_3_0 => { + let variant: pipelinerun_queued_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, PIPELINERUN_QUEUED_0_1_1 => { let variant: pipelinerun_queued_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -583,6 +904,10 @@ impl Content { let variant: pipelinerun_queued_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + PIPELINERUN_STARTED_0_3_0 => { + let variant: pipelinerun_started_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, PIPELINERUN_STARTED_0_1_1 => { let variant: pipelinerun_started_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -591,6 +916,10 @@ impl Content { let variant: pipelinerun_started_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + REPOSITORY_CREATED_0_3_0 => { + let variant: repository_created_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, REPOSITORY_CREATED_0_1_1 => { let variant: repository_created_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -599,6 +928,10 @@ impl Content { let variant: repository_created_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + REPOSITORY_DELETED_0_3_0 => { + let variant: repository_deleted_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, REPOSITORY_DELETED_0_1_1 => { let variant: repository_deleted_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -607,6 +940,10 @@ impl Content { let variant: repository_deleted_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + REPOSITORY_MODIFIED_0_3_0 => { + let variant: repository_modified_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, REPOSITORY_MODIFIED_0_1_1 => { let variant: repository_modified_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -615,6 +952,10 @@ impl Content { let variant: repository_modified_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + SERVICE_DEPLOYED_0_3_0 => { + let variant: service_deployed_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, SERVICE_DEPLOYED_0_1_1 => { let variant: service_deployed_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -623,6 +964,10 @@ impl Content { let variant: service_deployed_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + SERVICE_PUBLISHED_0_3_0 => { + let variant: service_published_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, SERVICE_PUBLISHED_0_1_1 => { let variant: service_published_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -631,6 +976,10 @@ impl Content { let variant: service_published_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + SERVICE_REMOVED_0_3_0 => { + let variant: service_removed_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, SERVICE_REMOVED_0_1_1 => { let variant: service_removed_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -639,6 +988,10 @@ impl Content { let variant: service_removed_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + SERVICE_ROLLEDBACK_0_3_0 => { + let variant: service_rolledback_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, SERVICE_ROLLEDBACK_0_1_1 => { let variant: service_rolledback_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -647,6 +1000,10 @@ impl Content { let variant: service_rolledback_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + SERVICE_UPGRADED_0_3_0 => { + let variant: service_upgraded_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, SERVICE_UPGRADED_0_1_1 => { let variant: service_upgraded_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -655,6 +1012,10 @@ impl Content { let variant: service_upgraded_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TASKRUN_FINISHED_0_3_0 => { + let variant: taskrun_finished_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TASKRUN_FINISHED_0_1_1 => { let variant: taskrun_finished_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -663,6 +1024,10 @@ impl Content { let variant: taskrun_finished_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TASKRUN_STARTED_0_3_0 => { + let variant: taskrun_started_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TASKRUN_STARTED_0_1_1 => { let variant: taskrun_started_0_1_1::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -671,6 +1036,10 @@ impl Content { let variant: taskrun_started_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTCASERUN_FINISHED_0_3_0 => { + let variant: testcaserun_finished_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTCASERUN_FINISHED_0_1_0 => { let variant: testcaserun_finished_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -679,6 +1048,10 @@ impl Content { let variant: testcaserun_finished_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTCASERUN_QUEUED_0_3_0 => { + let variant: testcaserun_queued_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTCASERUN_QUEUED_0_1_0 => { let variant: testcaserun_queued_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -687,10 +1060,18 @@ impl Content { let variant: testcaserun_queued_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTCASERUN_SKIPPED_0_2_0 => { + let variant: testcaserun_skipped_0_2_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTCASERUN_SKIPPED_0_1_0 => { let variant: testcaserun_skipped_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTCASERUN_STARTED_0_3_0 => { + let variant: testcaserun_started_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTCASERUN_STARTED_0_1_0 => { let variant: testcaserun_started_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -699,6 +1080,10 @@ impl Content { let variant: testcaserun_started_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTOUTPUT_PUBLISHED_0_3_0 => { + let variant: testoutput_published_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTOUTPUT_PUBLISHED_0_1_0 => { let variant: testoutput_published_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -707,6 +1092,10 @@ impl Content { let variant: testoutput_published_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTSUITERUN_FINISHED_0_3_0 => { + let variant: testsuiterun_finished_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTSUITERUN_FINISHED_0_1_0 => { let variant: testsuiterun_finished_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -715,6 +1104,10 @@ impl Content { let variant: testsuiterun_finished_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTSUITERUN_QUEUED_0_3_0 => { + let variant: testsuiterun_queued_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTSUITERUN_QUEUED_0_1_0 => { let variant: testsuiterun_queued_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -723,6 +1116,10 @@ impl Content { let variant: testsuiterun_queued_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TESTSUITERUN_STARTED_0_3_0 => { + let variant: testsuiterun_started_0_3_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TESTSUITERUN_STARTED_0_1_0 => { let variant: testsuiterun_started_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -731,14 +1128,26 @@ impl Content { let variant: testsuiterun_started_0_2_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TICKET_CLOSED_0_2_0 => { + let variant: ticket_closed_0_2_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TICKET_CLOSED_0_1_0 => { let variant: ticket_closed_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TICKET_CREATED_0_2_0 => { + let variant: ticket_created_0_2_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TICKET_CREATED_0_1_0 => { let variant: ticket_created_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) }, + TICKET_UPDATED_0_2_0 => { + let variant: ticket_updated_0_2_0::Content = serde_json::from_value(json)?; + Ok(variant.into()) + }, TICKET_UPDATED_0_1_0 => { let variant: ticket_updated_0_1_0::Content = serde_json::from_value(json)?; Ok(variant.into()) @@ -756,89 +1165,134 @@ impl Content { pub fn ty(&self) -> &str { match self { + Self::ArtifactDeleted020(_) => ARTIFACT_DELETED_0_2_0, Self::ArtifactDeleted010(_) => ARTIFACT_DELETED_0_1_0, + Self::ArtifactDownloaded020(_) => ARTIFACT_DOWNLOADED_0_2_0, Self::ArtifactDownloaded010(_) => ARTIFACT_DOWNLOADED_0_1_0, + Self::ArtifactPackaged030(_) => ARTIFACT_PACKAGED_0_3_0, Self::ArtifactPackaged011(_) => ARTIFACT_PACKAGED_0_1_1, Self::ArtifactPackaged020(_) => ARTIFACT_PACKAGED_0_2_0, + Self::ArtifactPublished030(_) => ARTIFACT_PUBLISHED_0_3_0, Self::ArtifactPublished011(_) => ARTIFACT_PUBLISHED_0_1_1, Self::ArtifactPublished020(_) => ARTIFACT_PUBLISHED_0_2_0, + Self::ArtifactSigned030(_) => ARTIFACT_SIGNED_0_3_0, Self::ArtifactSigned010(_) => ARTIFACT_SIGNED_0_1_0, Self::ArtifactSigned020(_) => ARTIFACT_SIGNED_0_2_0, + Self::BranchCreated030(_) => BRANCH_CREATED_0_3_0, Self::BranchCreated012(_) => BRANCH_CREATED_0_1_2, Self::BranchCreated020(_) => BRANCH_CREATED_0_2_0, + Self::BranchDeleted030(_) => BRANCH_DELETED_0_3_0, Self::BranchDeleted012(_) => BRANCH_DELETED_0_1_2, Self::BranchDeleted020(_) => BRANCH_DELETED_0_2_0, + Self::BuildFinished030(_) => BUILD_FINISHED_0_3_0, Self::BuildFinished011(_) => BUILD_FINISHED_0_1_1, Self::BuildFinished020(_) => BUILD_FINISHED_0_2_0, + Self::BuildQueued030(_) => BUILD_QUEUED_0_3_0, Self::BuildQueued011(_) => BUILD_QUEUED_0_1_1, Self::BuildQueued020(_) => BUILD_QUEUED_0_2_0, + Self::BuildStarted030(_) => BUILD_STARTED_0_3_0, Self::BuildStarted011(_) => BUILD_STARTED_0_1_1, Self::BuildStarted020(_) => BUILD_STARTED_0_2_0, + Self::ChangeAbandoned030(_) => CHANGE_ABANDONED_0_3_0, Self::ChangeAbandoned012(_) => CHANGE_ABANDONED_0_1_2, Self::ChangeAbandoned020(_) => CHANGE_ABANDONED_0_2_0, + Self::ChangeCreated040(_) => CHANGE_CREATED_0_4_0, Self::ChangeCreated012(_) => CHANGE_CREATED_0_1_2, Self::ChangeCreated030(_) => CHANGE_CREATED_0_3_0, + Self::ChangeMerged030(_) => CHANGE_MERGED_0_3_0, Self::ChangeMerged012(_) => CHANGE_MERGED_0_1_2, Self::ChangeMerged020(_) => CHANGE_MERGED_0_2_0, + Self::ChangeReviewed030(_) => CHANGE_REVIEWED_0_3_0, Self::ChangeReviewed012(_) => CHANGE_REVIEWED_0_1_2, Self::ChangeReviewed020(_) => CHANGE_REVIEWED_0_2_0, + Self::ChangeUpdated030(_) => CHANGE_UPDATED_0_3_0, Self::ChangeUpdated012(_) => CHANGE_UPDATED_0_1_2, Self::ChangeUpdated020(_) => CHANGE_UPDATED_0_2_0, + Self::EnvironmentCreated030(_) => ENVIRONMENT_CREATED_0_3_0, Self::EnvironmentCreated011(_) => ENVIRONMENT_CREATED_0_1_1, Self::EnvironmentCreated020(_) => ENVIRONMENT_CREATED_0_2_0, + Self::EnvironmentDeleted030(_) => ENVIRONMENT_DELETED_0_3_0, Self::EnvironmentDeleted011(_) => ENVIRONMENT_DELETED_0_1_1, Self::EnvironmentDeleted020(_) => ENVIRONMENT_DELETED_0_2_0, + Self::EnvironmentModified030(_) => ENVIRONMENT_MODIFIED_0_3_0, Self::EnvironmentModified011(_) => ENVIRONMENT_MODIFIED_0_1_1, Self::EnvironmentModified020(_) => ENVIRONMENT_MODIFIED_0_2_0, + Self::IncidentDetected030(_) => INCIDENT_DETECTED_0_3_0, Self::IncidentDetected010(_) => INCIDENT_DETECTED_0_1_0, Self::IncidentDetected020(_) => INCIDENT_DETECTED_0_2_0, + Self::IncidentReported030(_) => INCIDENT_REPORTED_0_3_0, Self::IncidentReported010(_) => INCIDENT_REPORTED_0_1_0, Self::IncidentReported020(_) => INCIDENT_REPORTED_0_2_0, + Self::IncidentResolved030(_) => INCIDENT_RESOLVED_0_3_0, Self::IncidentResolved010(_) => INCIDENT_RESOLVED_0_1_0, Self::IncidentResolved020(_) => INCIDENT_RESOLVED_0_2_0, + Self::PipelinerunFinished030(_) => PIPELINERUN_FINISHED_0_3_0, Self::PipelinerunFinished011(_) => PIPELINERUN_FINISHED_0_1_1, Self::PipelinerunFinished020(_) => PIPELINERUN_FINISHED_0_2_0, + Self::PipelinerunQueued030(_) => PIPELINERUN_QUEUED_0_3_0, Self::PipelinerunQueued011(_) => PIPELINERUN_QUEUED_0_1_1, Self::PipelinerunQueued020(_) => PIPELINERUN_QUEUED_0_2_0, + Self::PipelinerunStarted030(_) => PIPELINERUN_STARTED_0_3_0, Self::PipelinerunStarted011(_) => PIPELINERUN_STARTED_0_1_1, Self::PipelinerunStarted020(_) => PIPELINERUN_STARTED_0_2_0, + Self::RepositoryCreated030(_) => REPOSITORY_CREATED_0_3_0, Self::RepositoryCreated011(_) => REPOSITORY_CREATED_0_1_1, Self::RepositoryCreated020(_) => REPOSITORY_CREATED_0_2_0, + Self::RepositoryDeleted030(_) => REPOSITORY_DELETED_0_3_0, Self::RepositoryDeleted011(_) => REPOSITORY_DELETED_0_1_1, Self::RepositoryDeleted020(_) => REPOSITORY_DELETED_0_2_0, + Self::RepositoryModified030(_) => REPOSITORY_MODIFIED_0_3_0, Self::RepositoryModified011(_) => REPOSITORY_MODIFIED_0_1_1, Self::RepositoryModified020(_) => REPOSITORY_MODIFIED_0_2_0, + Self::ServiceDeployed030(_) => SERVICE_DEPLOYED_0_3_0, Self::ServiceDeployed011(_) => SERVICE_DEPLOYED_0_1_1, Self::ServiceDeployed020(_) => SERVICE_DEPLOYED_0_2_0, + Self::ServicePublished030(_) => SERVICE_PUBLISHED_0_3_0, Self::ServicePublished011(_) => SERVICE_PUBLISHED_0_1_1, Self::ServicePublished020(_) => SERVICE_PUBLISHED_0_2_0, + Self::ServiceRemoved030(_) => SERVICE_REMOVED_0_3_0, Self::ServiceRemoved011(_) => SERVICE_REMOVED_0_1_1, Self::ServiceRemoved020(_) => SERVICE_REMOVED_0_2_0, + Self::ServiceRolledback030(_) => SERVICE_ROLLEDBACK_0_3_0, Self::ServiceRolledback011(_) => SERVICE_ROLLEDBACK_0_1_1, Self::ServiceRolledback020(_) => SERVICE_ROLLEDBACK_0_2_0, + Self::ServiceUpgraded030(_) => SERVICE_UPGRADED_0_3_0, Self::ServiceUpgraded011(_) => SERVICE_UPGRADED_0_1_1, Self::ServiceUpgraded020(_) => SERVICE_UPGRADED_0_2_0, + Self::TaskrunFinished030(_) => TASKRUN_FINISHED_0_3_0, Self::TaskrunFinished011(_) => TASKRUN_FINISHED_0_1_1, Self::TaskrunFinished020(_) => TASKRUN_FINISHED_0_2_0, + Self::TaskrunStarted030(_) => TASKRUN_STARTED_0_3_0, Self::TaskrunStarted011(_) => TASKRUN_STARTED_0_1_1, Self::TaskrunStarted020(_) => TASKRUN_STARTED_0_2_0, + Self::TestcaserunFinished030(_) => TESTCASERUN_FINISHED_0_3_0, Self::TestcaserunFinished010(_) => TESTCASERUN_FINISHED_0_1_0, Self::TestcaserunFinished020(_) => TESTCASERUN_FINISHED_0_2_0, + Self::TestcaserunQueued030(_) => TESTCASERUN_QUEUED_0_3_0, Self::TestcaserunQueued010(_) => TESTCASERUN_QUEUED_0_1_0, Self::TestcaserunQueued020(_) => TESTCASERUN_QUEUED_0_2_0, + Self::TestcaserunSkipped020(_) => TESTCASERUN_SKIPPED_0_2_0, Self::TestcaserunSkipped010(_) => TESTCASERUN_SKIPPED_0_1_0, + Self::TestcaserunStarted030(_) => TESTCASERUN_STARTED_0_3_0, Self::TestcaserunStarted010(_) => TESTCASERUN_STARTED_0_1_0, Self::TestcaserunStarted020(_) => TESTCASERUN_STARTED_0_2_0, + Self::TestoutputPublished030(_) => TESTOUTPUT_PUBLISHED_0_3_0, Self::TestoutputPublished010(_) => TESTOUTPUT_PUBLISHED_0_1_0, Self::TestoutputPublished020(_) => TESTOUTPUT_PUBLISHED_0_2_0, + Self::TestsuiterunFinished030(_) => TESTSUITERUN_FINISHED_0_3_0, Self::TestsuiterunFinished010(_) => TESTSUITERUN_FINISHED_0_1_0, Self::TestsuiterunFinished020(_) => TESTSUITERUN_FINISHED_0_2_0, + Self::TestsuiterunQueued030(_) => TESTSUITERUN_QUEUED_0_3_0, Self::TestsuiterunQueued010(_) => TESTSUITERUN_QUEUED_0_1_0, Self::TestsuiterunQueued020(_) => TESTSUITERUN_QUEUED_0_2_0, + Self::TestsuiterunStarted030(_) => TESTSUITERUN_STARTED_0_3_0, Self::TestsuiterunStarted010(_) => TESTSUITERUN_STARTED_0_1_0, Self::TestsuiterunStarted020(_) => TESTSUITERUN_STARTED_0_2_0, + Self::TicketClosed020(_) => TICKET_CLOSED_0_2_0, Self::TicketClosed010(_) => TICKET_CLOSED_0_1_0, + Self::TicketCreated020(_) => TICKET_CREATED_0_2_0, Self::TicketCreated010(_) => TICKET_CREATED_0_1_0, + Self::TicketUpdated020(_) => TICKET_UPDATED_0_2_0, Self::TicketUpdated010(_) => TICKET_UPDATED_0_1_0, Self::Custom{ty, ..} => ty, } @@ -846,89 +1300,134 @@ impl Content { pub fn subject(&self) -> &str { match self { + Self::ArtifactDeleted020(_) => "", Self::ArtifactDeleted010(_) => "artifact", + Self::ArtifactDownloaded020(_) => "", Self::ArtifactDownloaded010(_) => "artifact", + Self::ArtifactPackaged030(_) => "", Self::ArtifactPackaged011(_) => "artifact", Self::ArtifactPackaged020(_) => "artifact", + Self::ArtifactPublished030(_) => "", Self::ArtifactPublished011(_) => "artifact", Self::ArtifactPublished020(_) => "artifact", + Self::ArtifactSigned030(_) => "", Self::ArtifactSigned010(_) => "artifact", Self::ArtifactSigned020(_) => "artifact", + Self::BranchCreated030(_) => "", Self::BranchCreated012(_) => "branch", Self::BranchCreated020(_) => "branch", + Self::BranchDeleted030(_) => "", Self::BranchDeleted012(_) => "branch", Self::BranchDeleted020(_) => "branch", + Self::BuildFinished030(_) => "", Self::BuildFinished011(_) => "build", Self::BuildFinished020(_) => "build", + Self::BuildQueued030(_) => "", Self::BuildQueued011(_) => "build", Self::BuildQueued020(_) => "build", + Self::BuildStarted030(_) => "", Self::BuildStarted011(_) => "build", Self::BuildStarted020(_) => "build", + Self::ChangeAbandoned030(_) => "", Self::ChangeAbandoned012(_) => "change", Self::ChangeAbandoned020(_) => "change", + Self::ChangeCreated040(_) => "", Self::ChangeCreated012(_) => "change", Self::ChangeCreated030(_) => "change", + Self::ChangeMerged030(_) => "", Self::ChangeMerged012(_) => "change", Self::ChangeMerged020(_) => "change", + Self::ChangeReviewed030(_) => "", Self::ChangeReviewed012(_) => "change", Self::ChangeReviewed020(_) => "change", + Self::ChangeUpdated030(_) => "", Self::ChangeUpdated012(_) => "change", Self::ChangeUpdated020(_) => "change", + Self::EnvironmentCreated030(_) => "", Self::EnvironmentCreated011(_) => "environment", Self::EnvironmentCreated020(_) => "environment", + Self::EnvironmentDeleted030(_) => "", Self::EnvironmentDeleted011(_) => "environment", Self::EnvironmentDeleted020(_) => "environment", + Self::EnvironmentModified030(_) => "", Self::EnvironmentModified011(_) => "environment", Self::EnvironmentModified020(_) => "environment", + Self::IncidentDetected030(_) => "", Self::IncidentDetected010(_) => "incident", Self::IncidentDetected020(_) => "incident", + Self::IncidentReported030(_) => "", Self::IncidentReported010(_) => "incident", Self::IncidentReported020(_) => "incident", + Self::IncidentResolved030(_) => "", Self::IncidentResolved010(_) => "incident", Self::IncidentResolved020(_) => "incident", + Self::PipelinerunFinished030(_) => "", Self::PipelinerunFinished011(_) => "pipelineRun", Self::PipelinerunFinished020(_) => "pipelineRun", + Self::PipelinerunQueued030(_) => "", Self::PipelinerunQueued011(_) => "pipelineRun", Self::PipelinerunQueued020(_) => "pipelineRun", + Self::PipelinerunStarted030(_) => "", Self::PipelinerunStarted011(_) => "pipelineRun", Self::PipelinerunStarted020(_) => "pipelineRun", + Self::RepositoryCreated030(_) => "", Self::RepositoryCreated011(_) => "repository", Self::RepositoryCreated020(_) => "repository", + Self::RepositoryDeleted030(_) => "", Self::RepositoryDeleted011(_) => "repository", Self::RepositoryDeleted020(_) => "repository", + Self::RepositoryModified030(_) => "", Self::RepositoryModified011(_) => "repository", Self::RepositoryModified020(_) => "repository", + Self::ServiceDeployed030(_) => "", Self::ServiceDeployed011(_) => "service", Self::ServiceDeployed020(_) => "service", + Self::ServicePublished030(_) => "", Self::ServicePublished011(_) => "service", Self::ServicePublished020(_) => "service", + Self::ServiceRemoved030(_) => "", Self::ServiceRemoved011(_) => "service", Self::ServiceRemoved020(_) => "service", + Self::ServiceRolledback030(_) => "", Self::ServiceRolledback011(_) => "service", Self::ServiceRolledback020(_) => "service", + Self::ServiceUpgraded030(_) => "", Self::ServiceUpgraded011(_) => "service", Self::ServiceUpgraded020(_) => "service", + Self::TaskrunFinished030(_) => "", Self::TaskrunFinished011(_) => "taskRun", Self::TaskrunFinished020(_) => "taskRun", + Self::TaskrunStarted030(_) => "", Self::TaskrunStarted011(_) => "taskRun", Self::TaskrunStarted020(_) => "taskRun", + Self::TestcaserunFinished030(_) => "", Self::TestcaserunFinished010(_) => "testCaseRun", Self::TestcaserunFinished020(_) => "testCaseRun", + Self::TestcaserunQueued030(_) => "", Self::TestcaserunQueued010(_) => "testCaseRun", Self::TestcaserunQueued020(_) => "testCaseRun", + Self::TestcaserunSkipped020(_) => "", Self::TestcaserunSkipped010(_) => "testCaseRun", + Self::TestcaserunStarted030(_) => "", Self::TestcaserunStarted010(_) => "testCaseRun", Self::TestcaserunStarted020(_) => "testCaseRun", + Self::TestoutputPublished030(_) => "", Self::TestoutputPublished010(_) => "testOutput", Self::TestoutputPublished020(_) => "testOutput", + Self::TestsuiterunFinished030(_) => "", Self::TestsuiterunFinished010(_) => "testSuiteRun", Self::TestsuiterunFinished020(_) => "testSuiteRun", + Self::TestsuiterunQueued030(_) => "", Self::TestsuiterunQueued010(_) => "testSuiteRun", Self::TestsuiterunQueued020(_) => "testSuiteRun", + Self::TestsuiterunStarted030(_) => "", Self::TestsuiterunStarted010(_) => "testSuiteRun", Self::TestsuiterunStarted020(_) => "testSuiteRun", + Self::TicketClosed020(_) => "ticket", Self::TicketClosed010(_) => "ticket", + Self::TicketCreated020(_) => "", Self::TicketCreated010(_) => "ticket", + Self::TicketUpdated020(_) => "", Self::TicketUpdated010(_) => "ticket", Self::Custom{ty, ..} => ty.split('.').nth(2).unwrap_or_default(), } @@ -936,89 +1435,134 @@ impl Content { pub fn predicate(&self) -> &str { match self { + Self::ArtifactDeleted020(_) => "deleted", Self::ArtifactDeleted010(_) => "deleted", + Self::ArtifactDownloaded020(_) => "downloaded", Self::ArtifactDownloaded010(_) => "downloaded", + Self::ArtifactPackaged030(_) => "packaged", Self::ArtifactPackaged011(_) => "packaged", Self::ArtifactPackaged020(_) => "packaged", + Self::ArtifactPublished030(_) => "published", Self::ArtifactPublished011(_) => "published", Self::ArtifactPublished020(_) => "published", + Self::ArtifactSigned030(_) => "signed", Self::ArtifactSigned010(_) => "signed", Self::ArtifactSigned020(_) => "signed", + Self::BranchCreated030(_) => "created", Self::BranchCreated012(_) => "created", Self::BranchCreated020(_) => "created", + Self::BranchDeleted030(_) => "deleted", Self::BranchDeleted012(_) => "deleted", Self::BranchDeleted020(_) => "deleted", + Self::BuildFinished030(_) => "finished", Self::BuildFinished011(_) => "finished", Self::BuildFinished020(_) => "finished", + Self::BuildQueued030(_) => "queued", Self::BuildQueued011(_) => "queued", Self::BuildQueued020(_) => "queued", + Self::BuildStarted030(_) => "started", Self::BuildStarted011(_) => "started", Self::BuildStarted020(_) => "started", + Self::ChangeAbandoned030(_) => "abandoned", Self::ChangeAbandoned012(_) => "abandoned", Self::ChangeAbandoned020(_) => "abandoned", + Self::ChangeCreated040(_) => "created", Self::ChangeCreated012(_) => "created", Self::ChangeCreated030(_) => "created", + Self::ChangeMerged030(_) => "merged", Self::ChangeMerged012(_) => "merged", Self::ChangeMerged020(_) => "merged", + Self::ChangeReviewed030(_) => "reviewed", Self::ChangeReviewed012(_) => "reviewed", Self::ChangeReviewed020(_) => "reviewed", + Self::ChangeUpdated030(_) => "updated", Self::ChangeUpdated012(_) => "updated", Self::ChangeUpdated020(_) => "updated", + Self::EnvironmentCreated030(_) => "created", Self::EnvironmentCreated011(_) => "created", Self::EnvironmentCreated020(_) => "created", + Self::EnvironmentDeleted030(_) => "deleted", Self::EnvironmentDeleted011(_) => "deleted", Self::EnvironmentDeleted020(_) => "deleted", + Self::EnvironmentModified030(_) => "modified", Self::EnvironmentModified011(_) => "modified", Self::EnvironmentModified020(_) => "modified", + Self::IncidentDetected030(_) => "detected", Self::IncidentDetected010(_) => "detected", Self::IncidentDetected020(_) => "detected", + Self::IncidentReported030(_) => "reported", Self::IncidentReported010(_) => "reported", Self::IncidentReported020(_) => "reported", + Self::IncidentResolved030(_) => "resolved", Self::IncidentResolved010(_) => "resolved", Self::IncidentResolved020(_) => "resolved", + Self::PipelinerunFinished030(_) => "finished", Self::PipelinerunFinished011(_) => "finished", Self::PipelinerunFinished020(_) => "finished", + Self::PipelinerunQueued030(_) => "queued", Self::PipelinerunQueued011(_) => "queued", Self::PipelinerunQueued020(_) => "queued", + Self::PipelinerunStarted030(_) => "started", Self::PipelinerunStarted011(_) => "started", Self::PipelinerunStarted020(_) => "started", + Self::RepositoryCreated030(_) => "created", Self::RepositoryCreated011(_) => "created", Self::RepositoryCreated020(_) => "created", + Self::RepositoryDeleted030(_) => "deleted", Self::RepositoryDeleted011(_) => "deleted", Self::RepositoryDeleted020(_) => "deleted", + Self::RepositoryModified030(_) => "modified", Self::RepositoryModified011(_) => "modified", Self::RepositoryModified020(_) => "modified", + Self::ServiceDeployed030(_) => "deployed", Self::ServiceDeployed011(_) => "deployed", Self::ServiceDeployed020(_) => "deployed", + Self::ServicePublished030(_) => "published", Self::ServicePublished011(_) => "published", Self::ServicePublished020(_) => "published", + Self::ServiceRemoved030(_) => "removed", Self::ServiceRemoved011(_) => "removed", Self::ServiceRemoved020(_) => "removed", + Self::ServiceRolledback030(_) => "rolledback", Self::ServiceRolledback011(_) => "rolledback", Self::ServiceRolledback020(_) => "rolledback", + Self::ServiceUpgraded030(_) => "upgraded", Self::ServiceUpgraded011(_) => "upgraded", Self::ServiceUpgraded020(_) => "upgraded", + Self::TaskrunFinished030(_) => "finished", Self::TaskrunFinished011(_) => "finished", Self::TaskrunFinished020(_) => "finished", + Self::TaskrunStarted030(_) => "started", Self::TaskrunStarted011(_) => "started", Self::TaskrunStarted020(_) => "started", + Self::TestcaserunFinished030(_) => "finished", Self::TestcaserunFinished010(_) => "finished", Self::TestcaserunFinished020(_) => "finished", + Self::TestcaserunQueued030(_) => "queued", Self::TestcaserunQueued010(_) => "queued", Self::TestcaserunQueued020(_) => "queued", + Self::TestcaserunSkipped020(_) => "skipped", Self::TestcaserunSkipped010(_) => "skipped", + Self::TestcaserunStarted030(_) => "started", Self::TestcaserunStarted010(_) => "started", Self::TestcaserunStarted020(_) => "started", + Self::TestoutputPublished030(_) => "published", Self::TestoutputPublished010(_) => "published", Self::TestoutputPublished020(_) => "published", + Self::TestsuiterunFinished030(_) => "finished", Self::TestsuiterunFinished010(_) => "finished", Self::TestsuiterunFinished020(_) => "finished", + Self::TestsuiterunQueued030(_) => "queued", Self::TestsuiterunQueued010(_) => "queued", Self::TestsuiterunQueued020(_) => "queued", + Self::TestsuiterunStarted030(_) => "started", Self::TestsuiterunStarted010(_) => "started", Self::TestsuiterunStarted020(_) => "started", + Self::TicketClosed020(_) => "closed", Self::TicketClosed010(_) => "closed", + Self::TicketCreated020(_) => "created", Self::TicketCreated010(_) => "created", + Self::TicketUpdated020(_) => "updated", Self::TicketUpdated010(_) => "updated", Self::Custom{ty, ..} => ty.split('.').nth(3).unwrap_or_default(), } @@ -1118,16 +1662,124 @@ pub fn extract_subject_predicate(ty: &str) -> Option<(&str, &str)>{ } } +/// Due to inconstency in case/format the subject could be not be extracted from the context.type (ty), jsonshema $id, spec filename (shema, examples) +/// Custom type are not supported +pub(crate) fn new_context(ty: &str) -> crate::context::ContextEnum { + use crate::context::{ContextEnum, Context_0_3, Context_0_4, Context_0_5}; + match ty { + ARTIFACT_DELETED_0_1_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + ARTIFACT_DOWNLOADED_0_1_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + ARTIFACT_PACKAGED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + ARTIFACT_PACKAGED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + ARTIFACT_PUBLISHED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + ARTIFACT_PUBLISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + ARTIFACT_SIGNED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + ARTIFACT_SIGNED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + BRANCH_CREATED_0_1_2 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + BRANCH_CREATED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + BRANCH_DELETED_0_1_2 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + BRANCH_DELETED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + BUILD_FINISHED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + BUILD_FINISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + BUILD_QUEUED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + BUILD_QUEUED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + BUILD_STARTED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + BUILD_STARTED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + CHANGE_ABANDONED_0_1_2 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + CHANGE_ABANDONED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + CHANGE_CREATED_0_1_2 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + CHANGE_CREATED_0_3_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + CHANGE_MERGED_0_1_2 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + CHANGE_MERGED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + CHANGE_REVIEWED_0_1_2 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + CHANGE_REVIEWED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + CHANGE_UPDATED_0_1_2 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + CHANGE_UPDATED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + ENVIRONMENT_CREATED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + ENVIRONMENT_CREATED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + ENVIRONMENT_DELETED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + ENVIRONMENT_DELETED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + ENVIRONMENT_MODIFIED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + ENVIRONMENT_MODIFIED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + INCIDENT_DETECTED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + INCIDENT_DETECTED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + INCIDENT_REPORTED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + INCIDENT_REPORTED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + INCIDENT_RESOLVED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + INCIDENT_RESOLVED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + PIPELINERUN_FINISHED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + PIPELINERUN_FINISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + PIPELINERUN_QUEUED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + PIPELINERUN_QUEUED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + PIPELINERUN_STARTED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + PIPELINERUN_STARTED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + REPOSITORY_CREATED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + REPOSITORY_CREATED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + REPOSITORY_DELETED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + REPOSITORY_DELETED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + REPOSITORY_MODIFIED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + REPOSITORY_MODIFIED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + SERVICE_DEPLOYED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + SERVICE_DEPLOYED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + SERVICE_PUBLISHED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + SERVICE_PUBLISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + SERVICE_REMOVED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + SERVICE_REMOVED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + SERVICE_ROLLEDBACK_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + SERVICE_ROLLEDBACK_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + SERVICE_UPGRADED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + SERVICE_UPGRADED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TASKRUN_FINISHED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TASKRUN_FINISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TASKRUN_STARTED_0_1_1 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TASKRUN_STARTED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTCASERUN_FINISHED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TESTCASERUN_FINISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTCASERUN_QUEUED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TESTCASERUN_QUEUED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTCASERUN_SKIPPED_0_1_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTCASERUN_STARTED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TESTCASERUN_STARTED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTOUTPUT_PUBLISHED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TESTOUTPUT_PUBLISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTSUITERUN_FINISHED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TESTSUITERUN_FINISHED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTSUITERUN_QUEUED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TESTSUITERUN_QUEUED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TESTSUITERUN_STARTED_0_1_0 => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + TESTSUITERUN_STARTED_0_2_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TICKET_CLOSED_0_1_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TICKET_CREATED_0_1_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + TICKET_UPDATED_0_1_0 => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + _ => ContextEnum::Context_0_5(Context_0_5::new(ty.into())), + } +} + +impl From for Content { + fn from(value: artifact_deleted_0_2_0::Content) -> Self { + Self::ArtifactDeleted020(value) + } +} impl From for Content { fn from(value: artifact_deleted_0_1_0::Content) -> Self { Self::ArtifactDeleted010(value) } } +impl From for Content { + fn from(value: artifact_downloaded_0_2_0::Content) -> Self { + Self::ArtifactDownloaded020(value) + } +} impl From for Content { fn from(value: artifact_downloaded_0_1_0::Content) -> Self { Self::ArtifactDownloaded010(value) } } +impl From for Content { + fn from(value: artifact_packaged_0_3_0::Content) -> Self { + Self::ArtifactPackaged030(value) + } +} impl From for Content { fn from(value: artifact_packaged_0_1_1::Content) -> Self { Self::ArtifactPackaged011(value) @@ -1138,6 +1790,11 @@ impl From for Content { Self::ArtifactPackaged020(value) } } +impl From for Content { + fn from(value: artifact_published_0_3_0::Content) -> Self { + Self::ArtifactPublished030(value) + } +} impl From for Content { fn from(value: artifact_published_0_1_1::Content) -> Self { Self::ArtifactPublished011(value) @@ -1148,6 +1805,11 @@ impl From for Content { Self::ArtifactPublished020(value) } } +impl From for Content { + fn from(value: artifact_signed_0_3_0::Content) -> Self { + Self::ArtifactSigned030(value) + } +} impl From for Content { fn from(value: artifact_signed_0_1_0::Content) -> Self { Self::ArtifactSigned010(value) @@ -1158,6 +1820,11 @@ impl From for Content { Self::ArtifactSigned020(value) } } +impl From for Content { + fn from(value: branch_created_0_3_0::Content) -> Self { + Self::BranchCreated030(value) + } +} impl From for Content { fn from(value: branch_created_0_1_2::Content) -> Self { Self::BranchCreated012(value) @@ -1168,6 +1835,11 @@ impl From for Content { Self::BranchCreated020(value) } } +impl From for Content { + fn from(value: branch_deleted_0_3_0::Content) -> Self { + Self::BranchDeleted030(value) + } +} impl From for Content { fn from(value: branch_deleted_0_1_2::Content) -> Self { Self::BranchDeleted012(value) @@ -1178,6 +1850,11 @@ impl From for Content { Self::BranchDeleted020(value) } } +impl From for Content { + fn from(value: build_finished_0_3_0::Content) -> Self { + Self::BuildFinished030(value) + } +} impl From for Content { fn from(value: build_finished_0_1_1::Content) -> Self { Self::BuildFinished011(value) @@ -1188,6 +1865,11 @@ impl From for Content { Self::BuildFinished020(value) } } +impl From for Content { + fn from(value: build_queued_0_3_0::Content) -> Self { + Self::BuildQueued030(value) + } +} impl From for Content { fn from(value: build_queued_0_1_1::Content) -> Self { Self::BuildQueued011(value) @@ -1198,6 +1880,11 @@ impl From for Content { Self::BuildQueued020(value) } } +impl From for Content { + fn from(value: build_started_0_3_0::Content) -> Self { + Self::BuildStarted030(value) + } +} impl From for Content { fn from(value: build_started_0_1_1::Content) -> Self { Self::BuildStarted011(value) @@ -1208,6 +1895,11 @@ impl From for Content { Self::BuildStarted020(value) } } +impl From for Content { + fn from(value: change_abandoned_0_3_0::Content) -> Self { + Self::ChangeAbandoned030(value) + } +} impl From for Content { fn from(value: change_abandoned_0_1_2::Content) -> Self { Self::ChangeAbandoned012(value) @@ -1218,6 +1910,11 @@ impl From for Content { Self::ChangeAbandoned020(value) } } +impl From for Content { + fn from(value: change_created_0_4_0::Content) -> Self { + Self::ChangeCreated040(value) + } +} impl From for Content { fn from(value: change_created_0_1_2::Content) -> Self { Self::ChangeCreated012(value) @@ -1228,6 +1925,11 @@ impl From for Content { Self::ChangeCreated030(value) } } +impl From for Content { + fn from(value: change_merged_0_3_0::Content) -> Self { + Self::ChangeMerged030(value) + } +} impl From for Content { fn from(value: change_merged_0_1_2::Content) -> Self { Self::ChangeMerged012(value) @@ -1238,6 +1940,11 @@ impl From for Content { Self::ChangeMerged020(value) } } +impl From for Content { + fn from(value: change_reviewed_0_3_0::Content) -> Self { + Self::ChangeReviewed030(value) + } +} impl From for Content { fn from(value: change_reviewed_0_1_2::Content) -> Self { Self::ChangeReviewed012(value) @@ -1248,6 +1955,11 @@ impl From for Content { Self::ChangeReviewed020(value) } } +impl From for Content { + fn from(value: change_updated_0_3_0::Content) -> Self { + Self::ChangeUpdated030(value) + } +} impl From for Content { fn from(value: change_updated_0_1_2::Content) -> Self { Self::ChangeUpdated012(value) @@ -1258,6 +1970,11 @@ impl From for Content { Self::ChangeUpdated020(value) } } +impl From for Content { + fn from(value: environment_created_0_3_0::Content) -> Self { + Self::EnvironmentCreated030(value) + } +} impl From for Content { fn from(value: environment_created_0_1_1::Content) -> Self { Self::EnvironmentCreated011(value) @@ -1268,6 +1985,11 @@ impl From for Content { Self::EnvironmentCreated020(value) } } +impl From for Content { + fn from(value: environment_deleted_0_3_0::Content) -> Self { + Self::EnvironmentDeleted030(value) + } +} impl From for Content { fn from(value: environment_deleted_0_1_1::Content) -> Self { Self::EnvironmentDeleted011(value) @@ -1278,6 +2000,11 @@ impl From for Content { Self::EnvironmentDeleted020(value) } } +impl From for Content { + fn from(value: environment_modified_0_3_0::Content) -> Self { + Self::EnvironmentModified030(value) + } +} impl From for Content { fn from(value: environment_modified_0_1_1::Content) -> Self { Self::EnvironmentModified011(value) @@ -1288,6 +2015,11 @@ impl From for Content { Self::EnvironmentModified020(value) } } +impl From for Content { + fn from(value: incident_detected_0_3_0::Content) -> Self { + Self::IncidentDetected030(value) + } +} impl From for Content { fn from(value: incident_detected_0_1_0::Content) -> Self { Self::IncidentDetected010(value) @@ -1298,6 +2030,11 @@ impl From for Content { Self::IncidentDetected020(value) } } +impl From for Content { + fn from(value: incident_reported_0_3_0::Content) -> Self { + Self::IncidentReported030(value) + } +} impl From for Content { fn from(value: incident_reported_0_1_0::Content) -> Self { Self::IncidentReported010(value) @@ -1308,6 +2045,11 @@ impl From for Content { Self::IncidentReported020(value) } } +impl From for Content { + fn from(value: incident_resolved_0_3_0::Content) -> Self { + Self::IncidentResolved030(value) + } +} impl From for Content { fn from(value: incident_resolved_0_1_0::Content) -> Self { Self::IncidentResolved010(value) @@ -1318,6 +2060,11 @@ impl From for Content { Self::IncidentResolved020(value) } } +impl From for Content { + fn from(value: pipelinerun_finished_0_3_0::Content) -> Self { + Self::PipelinerunFinished030(value) + } +} impl From for Content { fn from(value: pipelinerun_finished_0_1_1::Content) -> Self { Self::PipelinerunFinished011(value) @@ -1328,6 +2075,11 @@ impl From for Content { Self::PipelinerunFinished020(value) } } +impl From for Content { + fn from(value: pipelinerun_queued_0_3_0::Content) -> Self { + Self::PipelinerunQueued030(value) + } +} impl From for Content { fn from(value: pipelinerun_queued_0_1_1::Content) -> Self { Self::PipelinerunQueued011(value) @@ -1338,6 +2090,11 @@ impl From for Content { Self::PipelinerunQueued020(value) } } +impl From for Content { + fn from(value: pipelinerun_started_0_3_0::Content) -> Self { + Self::PipelinerunStarted030(value) + } +} impl From for Content { fn from(value: pipelinerun_started_0_1_1::Content) -> Self { Self::PipelinerunStarted011(value) @@ -1348,6 +2105,11 @@ impl From for Content { Self::PipelinerunStarted020(value) } } +impl From for Content { + fn from(value: repository_created_0_3_0::Content) -> Self { + Self::RepositoryCreated030(value) + } +} impl From for Content { fn from(value: repository_created_0_1_1::Content) -> Self { Self::RepositoryCreated011(value) @@ -1358,6 +2120,11 @@ impl From for Content { Self::RepositoryCreated020(value) } } +impl From for Content { + fn from(value: repository_deleted_0_3_0::Content) -> Self { + Self::RepositoryDeleted030(value) + } +} impl From for Content { fn from(value: repository_deleted_0_1_1::Content) -> Self { Self::RepositoryDeleted011(value) @@ -1368,6 +2135,11 @@ impl From for Content { Self::RepositoryDeleted020(value) } } +impl From for Content { + fn from(value: repository_modified_0_3_0::Content) -> Self { + Self::RepositoryModified030(value) + } +} impl From for Content { fn from(value: repository_modified_0_1_1::Content) -> Self { Self::RepositoryModified011(value) @@ -1378,6 +2150,11 @@ impl From for Content { Self::RepositoryModified020(value) } } +impl From for Content { + fn from(value: service_deployed_0_3_0::Content) -> Self { + Self::ServiceDeployed030(value) + } +} impl From for Content { fn from(value: service_deployed_0_1_1::Content) -> Self { Self::ServiceDeployed011(value) @@ -1388,6 +2165,11 @@ impl From for Content { Self::ServiceDeployed020(value) } } +impl From for Content { + fn from(value: service_published_0_3_0::Content) -> Self { + Self::ServicePublished030(value) + } +} impl From for Content { fn from(value: service_published_0_1_1::Content) -> Self { Self::ServicePublished011(value) @@ -1398,6 +2180,11 @@ impl From for Content { Self::ServicePublished020(value) } } +impl From for Content { + fn from(value: service_removed_0_3_0::Content) -> Self { + Self::ServiceRemoved030(value) + } +} impl From for Content { fn from(value: service_removed_0_1_1::Content) -> Self { Self::ServiceRemoved011(value) @@ -1408,6 +2195,11 @@ impl From for Content { Self::ServiceRemoved020(value) } } +impl From for Content { + fn from(value: service_rolledback_0_3_0::Content) -> Self { + Self::ServiceRolledback030(value) + } +} impl From for Content { fn from(value: service_rolledback_0_1_1::Content) -> Self { Self::ServiceRolledback011(value) @@ -1418,6 +2210,11 @@ impl From for Content { Self::ServiceRolledback020(value) } } +impl From for Content { + fn from(value: service_upgraded_0_3_0::Content) -> Self { + Self::ServiceUpgraded030(value) + } +} impl From for Content { fn from(value: service_upgraded_0_1_1::Content) -> Self { Self::ServiceUpgraded011(value) @@ -1428,6 +2225,11 @@ impl From for Content { Self::ServiceUpgraded020(value) } } +impl From for Content { + fn from(value: taskrun_finished_0_3_0::Content) -> Self { + Self::TaskrunFinished030(value) + } +} impl From for Content { fn from(value: taskrun_finished_0_1_1::Content) -> Self { Self::TaskrunFinished011(value) @@ -1438,6 +2240,11 @@ impl From for Content { Self::TaskrunFinished020(value) } } +impl From for Content { + fn from(value: taskrun_started_0_3_0::Content) -> Self { + Self::TaskrunStarted030(value) + } +} impl From for Content { fn from(value: taskrun_started_0_1_1::Content) -> Self { Self::TaskrunStarted011(value) @@ -1448,6 +2255,11 @@ impl From for Content { Self::TaskrunStarted020(value) } } +impl From for Content { + fn from(value: testcaserun_finished_0_3_0::Content) -> Self { + Self::TestcaserunFinished030(value) + } +} impl From for Content { fn from(value: testcaserun_finished_0_1_0::Content) -> Self { Self::TestcaserunFinished010(value) @@ -1458,6 +2270,11 @@ impl From for Content { Self::TestcaserunFinished020(value) } } +impl From for Content { + fn from(value: testcaserun_queued_0_3_0::Content) -> Self { + Self::TestcaserunQueued030(value) + } +} impl From for Content { fn from(value: testcaserun_queued_0_1_0::Content) -> Self { Self::TestcaserunQueued010(value) @@ -1468,11 +2285,21 @@ impl From for Content { Self::TestcaserunQueued020(value) } } +impl From for Content { + fn from(value: testcaserun_skipped_0_2_0::Content) -> Self { + Self::TestcaserunSkipped020(value) + } +} impl From for Content { fn from(value: testcaserun_skipped_0_1_0::Content) -> Self { Self::TestcaserunSkipped010(value) } } +impl From for Content { + fn from(value: testcaserun_started_0_3_0::Content) -> Self { + Self::TestcaserunStarted030(value) + } +} impl From for Content { fn from(value: testcaserun_started_0_1_0::Content) -> Self { Self::TestcaserunStarted010(value) @@ -1483,6 +2310,11 @@ impl From for Content { Self::TestcaserunStarted020(value) } } +impl From for Content { + fn from(value: testoutput_published_0_3_0::Content) -> Self { + Self::TestoutputPublished030(value) + } +} impl From for Content { fn from(value: testoutput_published_0_1_0::Content) -> Self { Self::TestoutputPublished010(value) @@ -1493,6 +2325,11 @@ impl From for Content { Self::TestoutputPublished020(value) } } +impl From for Content { + fn from(value: testsuiterun_finished_0_3_0::Content) -> Self { + Self::TestsuiterunFinished030(value) + } +} impl From for Content { fn from(value: testsuiterun_finished_0_1_0::Content) -> Self { Self::TestsuiterunFinished010(value) @@ -1503,6 +2340,11 @@ impl From for Content { Self::TestsuiterunFinished020(value) } } +impl From for Content { + fn from(value: testsuiterun_queued_0_3_0::Content) -> Self { + Self::TestsuiterunQueued030(value) + } +} impl From for Content { fn from(value: testsuiterun_queued_0_1_0::Content) -> Self { Self::TestsuiterunQueued010(value) @@ -1513,6 +2355,11 @@ impl From for Content { Self::TestsuiterunQueued020(value) } } +impl From for Content { + fn from(value: testsuiterun_started_0_3_0::Content) -> Self { + Self::TestsuiterunStarted030(value) + } +} impl From for Content { fn from(value: testsuiterun_started_0_1_0::Content) -> Self { Self::TestsuiterunStarted010(value) @@ -1523,16 +2370,31 @@ impl From for Content { Self::TestsuiterunStarted020(value) } } +impl From for Content { + fn from(value: ticket_closed_0_2_0::Content) -> Self { + Self::TicketClosed020(value) + } +} impl From for Content { fn from(value: ticket_closed_0_1_0::Content) -> Self { Self::TicketClosed010(value) } } +impl From for Content { + fn from(value: ticket_created_0_2_0::Content) -> Self { + Self::TicketCreated020(value) + } +} impl From for Content { fn from(value: ticket_created_0_1_0::Content) -> Self { Self::TicketCreated010(value) } } +impl From for Content { + fn from(value: ticket_updated_0_2_0::Content) -> Self { + Self::TicketUpdated020(value) + } +} impl From for Content { fn from(value: ticket_updated_0_1_0::Content) -> Self { Self::TicketUpdated010(value) @@ -1547,89 +2409,134 @@ impl<> proptest::arbitrary::Arbitrary for Content { fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy { use proptest::prelude::*; prop_oneof![ + any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), + any::().prop_map(Content::from), any::().prop_map(Content::from), ].boxed() } @@ -1642,172 +2549,262 @@ impl<> proptest::arbitrary::Arbitrary for Content { // #[test] // fn test_true() { // +// assert_eq!(extract_subject_predicate(ARTIFACT_DELETED_0_2_0), Some(("artifact","deleted"))); +// // assert_eq!(extract_subject_predicate(ARTIFACT_DELETED_0_1_0), Some(("artifact","deleted"))); // +// assert_eq!(extract_subject_predicate(ARTIFACT_DOWNLOADED_0_2_0), Some(("artifact","downloaded"))); +// // assert_eq!(extract_subject_predicate(ARTIFACT_DOWNLOADED_0_1_0), Some(("artifact","downloaded"))); // +// assert_eq!(extract_subject_predicate(ARTIFACT_PACKAGED_0_3_0), Some(("artifact","packaged"))); +// // assert_eq!(extract_subject_predicate(ARTIFACT_PACKAGED_0_1_1), Some(("artifact","packaged"))); // // assert_eq!(extract_subject_predicate(ARTIFACT_PACKAGED_0_2_0), Some(("artifact","packaged"))); // +// assert_eq!(extract_subject_predicate(ARTIFACT_PUBLISHED_0_3_0), Some(("artifact","published"))); +// // assert_eq!(extract_subject_predicate(ARTIFACT_PUBLISHED_0_1_1), Some(("artifact","published"))); // // assert_eq!(extract_subject_predicate(ARTIFACT_PUBLISHED_0_2_0), Some(("artifact","published"))); // +// assert_eq!(extract_subject_predicate(ARTIFACT_SIGNED_0_3_0), Some(("artifact","signed"))); +// // assert_eq!(extract_subject_predicate(ARTIFACT_SIGNED_0_1_0), Some(("artifact","signed"))); // // assert_eq!(extract_subject_predicate(ARTIFACT_SIGNED_0_2_0), Some(("artifact","signed"))); // +// assert_eq!(extract_subject_predicate(BRANCH_CREATED_0_3_0), Some(("branch","created"))); +// // assert_eq!(extract_subject_predicate(BRANCH_CREATED_0_1_2), Some(("branch","created"))); // // assert_eq!(extract_subject_predicate(BRANCH_CREATED_0_2_0), Some(("branch","created"))); // +// assert_eq!(extract_subject_predicate(BRANCH_DELETED_0_3_0), Some(("branch","deleted"))); +// // assert_eq!(extract_subject_predicate(BRANCH_DELETED_0_1_2), Some(("branch","deleted"))); // // assert_eq!(extract_subject_predicate(BRANCH_DELETED_0_2_0), Some(("branch","deleted"))); // +// assert_eq!(extract_subject_predicate(BUILD_FINISHED_0_3_0), Some(("build","finished"))); +// // assert_eq!(extract_subject_predicate(BUILD_FINISHED_0_1_1), Some(("build","finished"))); // // assert_eq!(extract_subject_predicate(BUILD_FINISHED_0_2_0), Some(("build","finished"))); // +// assert_eq!(extract_subject_predicate(BUILD_QUEUED_0_3_0), Some(("build","queued"))); +// // assert_eq!(extract_subject_predicate(BUILD_QUEUED_0_1_1), Some(("build","queued"))); // // assert_eq!(extract_subject_predicate(BUILD_QUEUED_0_2_0), Some(("build","queued"))); // +// assert_eq!(extract_subject_predicate(BUILD_STARTED_0_3_0), Some(("build","started"))); +// // assert_eq!(extract_subject_predicate(BUILD_STARTED_0_1_1), Some(("build","started"))); // // assert_eq!(extract_subject_predicate(BUILD_STARTED_0_2_0), Some(("build","started"))); // +// assert_eq!(extract_subject_predicate(CHANGE_ABANDONED_0_3_0), Some(("change","abandoned"))); +// // assert_eq!(extract_subject_predicate(CHANGE_ABANDONED_0_1_2), Some(("change","abandoned"))); // // assert_eq!(extract_subject_predicate(CHANGE_ABANDONED_0_2_0), Some(("change","abandoned"))); // +// assert_eq!(extract_subject_predicate(CHANGE_CREATED_0_4_0), Some(("change","created"))); +// // assert_eq!(extract_subject_predicate(CHANGE_CREATED_0_1_2), Some(("change","created"))); // // assert_eq!(extract_subject_predicate(CHANGE_CREATED_0_3_0), Some(("change","created"))); // +// assert_eq!(extract_subject_predicate(CHANGE_MERGED_0_3_0), Some(("change","merged"))); +// // assert_eq!(extract_subject_predicate(CHANGE_MERGED_0_1_2), Some(("change","merged"))); // // assert_eq!(extract_subject_predicate(CHANGE_MERGED_0_2_0), Some(("change","merged"))); // +// assert_eq!(extract_subject_predicate(CHANGE_REVIEWED_0_3_0), Some(("change","reviewed"))); +// // assert_eq!(extract_subject_predicate(CHANGE_REVIEWED_0_1_2), Some(("change","reviewed"))); // // assert_eq!(extract_subject_predicate(CHANGE_REVIEWED_0_2_0), Some(("change","reviewed"))); // +// assert_eq!(extract_subject_predicate(CHANGE_UPDATED_0_3_0), Some(("change","updated"))); +// // assert_eq!(extract_subject_predicate(CHANGE_UPDATED_0_1_2), Some(("change","updated"))); // // assert_eq!(extract_subject_predicate(CHANGE_UPDATED_0_2_0), Some(("change","updated"))); // +// assert_eq!(extract_subject_predicate(ENVIRONMENT_CREATED_0_3_0), Some(("environment","created"))); +// // assert_eq!(extract_subject_predicate(ENVIRONMENT_CREATED_0_1_1), Some(("environment","created"))); // // assert_eq!(extract_subject_predicate(ENVIRONMENT_CREATED_0_2_0), Some(("environment","created"))); // +// assert_eq!(extract_subject_predicate(ENVIRONMENT_DELETED_0_3_0), Some(("environment","deleted"))); +// // assert_eq!(extract_subject_predicate(ENVIRONMENT_DELETED_0_1_1), Some(("environment","deleted"))); // // assert_eq!(extract_subject_predicate(ENVIRONMENT_DELETED_0_2_0), Some(("environment","deleted"))); // +// assert_eq!(extract_subject_predicate(ENVIRONMENT_MODIFIED_0_3_0), Some(("environment","modified"))); +// // assert_eq!(extract_subject_predicate(ENVIRONMENT_MODIFIED_0_1_1), Some(("environment","modified"))); // // assert_eq!(extract_subject_predicate(ENVIRONMENT_MODIFIED_0_2_0), Some(("environment","modified"))); // +// assert_eq!(extract_subject_predicate(INCIDENT_DETECTED_0_3_0), Some(("incident","detected"))); +// // assert_eq!(extract_subject_predicate(INCIDENT_DETECTED_0_1_0), Some(("incident","detected"))); // // assert_eq!(extract_subject_predicate(INCIDENT_DETECTED_0_2_0), Some(("incident","detected"))); // +// assert_eq!(extract_subject_predicate(INCIDENT_REPORTED_0_3_0), Some(("incident","reported"))); +// // assert_eq!(extract_subject_predicate(INCIDENT_REPORTED_0_1_0), Some(("incident","reported"))); // // assert_eq!(extract_subject_predicate(INCIDENT_REPORTED_0_2_0), Some(("incident","reported"))); // +// assert_eq!(extract_subject_predicate(INCIDENT_RESOLVED_0_3_0), Some(("incident","resolved"))); +// // assert_eq!(extract_subject_predicate(INCIDENT_RESOLVED_0_1_0), Some(("incident","resolved"))); // // assert_eq!(extract_subject_predicate(INCIDENT_RESOLVED_0_2_0), Some(("incident","resolved"))); // +// assert_eq!(extract_subject_predicate(PIPELINERUN_FINISHED_0_3_0), Some(("pipelinerun","finished"))); +// // assert_eq!(extract_subject_predicate(PIPELINERUN_FINISHED_0_1_1), Some(("pipelinerun","finished"))); // // assert_eq!(extract_subject_predicate(PIPELINERUN_FINISHED_0_2_0), Some(("pipelinerun","finished"))); // +// assert_eq!(extract_subject_predicate(PIPELINERUN_QUEUED_0_3_0), Some(("pipelinerun","queued"))); +// // assert_eq!(extract_subject_predicate(PIPELINERUN_QUEUED_0_1_1), Some(("pipelinerun","queued"))); // // assert_eq!(extract_subject_predicate(PIPELINERUN_QUEUED_0_2_0), Some(("pipelinerun","queued"))); // +// assert_eq!(extract_subject_predicate(PIPELINERUN_STARTED_0_3_0), Some(("pipelinerun","started"))); +// // assert_eq!(extract_subject_predicate(PIPELINERUN_STARTED_0_1_1), Some(("pipelinerun","started"))); // // assert_eq!(extract_subject_predicate(PIPELINERUN_STARTED_0_2_0), Some(("pipelinerun","started"))); // +// assert_eq!(extract_subject_predicate(REPOSITORY_CREATED_0_3_0), Some(("repository","created"))); +// // assert_eq!(extract_subject_predicate(REPOSITORY_CREATED_0_1_1), Some(("repository","created"))); // // assert_eq!(extract_subject_predicate(REPOSITORY_CREATED_0_2_0), Some(("repository","created"))); // +// assert_eq!(extract_subject_predicate(REPOSITORY_DELETED_0_3_0), Some(("repository","deleted"))); +// // assert_eq!(extract_subject_predicate(REPOSITORY_DELETED_0_1_1), Some(("repository","deleted"))); // // assert_eq!(extract_subject_predicate(REPOSITORY_DELETED_0_2_0), Some(("repository","deleted"))); // +// assert_eq!(extract_subject_predicate(REPOSITORY_MODIFIED_0_3_0), Some(("repository","modified"))); +// // assert_eq!(extract_subject_predicate(REPOSITORY_MODIFIED_0_1_1), Some(("repository","modified"))); // // assert_eq!(extract_subject_predicate(REPOSITORY_MODIFIED_0_2_0), Some(("repository","modified"))); // +// assert_eq!(extract_subject_predicate(SERVICE_DEPLOYED_0_3_0), Some(("service","deployed"))); +// // assert_eq!(extract_subject_predicate(SERVICE_DEPLOYED_0_1_1), Some(("service","deployed"))); // // assert_eq!(extract_subject_predicate(SERVICE_DEPLOYED_0_2_0), Some(("service","deployed"))); // +// assert_eq!(extract_subject_predicate(SERVICE_PUBLISHED_0_3_0), Some(("service","published"))); +// // assert_eq!(extract_subject_predicate(SERVICE_PUBLISHED_0_1_1), Some(("service","published"))); // // assert_eq!(extract_subject_predicate(SERVICE_PUBLISHED_0_2_0), Some(("service","published"))); // +// assert_eq!(extract_subject_predicate(SERVICE_REMOVED_0_3_0), Some(("service","removed"))); +// // assert_eq!(extract_subject_predicate(SERVICE_REMOVED_0_1_1), Some(("service","removed"))); // // assert_eq!(extract_subject_predicate(SERVICE_REMOVED_0_2_0), Some(("service","removed"))); // +// assert_eq!(extract_subject_predicate(SERVICE_ROLLEDBACK_0_3_0), Some(("service","rolledback"))); +// // assert_eq!(extract_subject_predicate(SERVICE_ROLLEDBACK_0_1_1), Some(("service","rolledback"))); // // assert_eq!(extract_subject_predicate(SERVICE_ROLLEDBACK_0_2_0), Some(("service","rolledback"))); // +// assert_eq!(extract_subject_predicate(SERVICE_UPGRADED_0_3_0), Some(("service","upgraded"))); +// // assert_eq!(extract_subject_predicate(SERVICE_UPGRADED_0_1_1), Some(("service","upgraded"))); // // assert_eq!(extract_subject_predicate(SERVICE_UPGRADED_0_2_0), Some(("service","upgraded"))); // +// assert_eq!(extract_subject_predicate(TASKRUN_FINISHED_0_3_0), Some(("taskrun","finished"))); +// // assert_eq!(extract_subject_predicate(TASKRUN_FINISHED_0_1_1), Some(("taskrun","finished"))); // // assert_eq!(extract_subject_predicate(TASKRUN_FINISHED_0_2_0), Some(("taskrun","finished"))); // +// assert_eq!(extract_subject_predicate(TASKRUN_STARTED_0_3_0), Some(("taskrun","started"))); +// // assert_eq!(extract_subject_predicate(TASKRUN_STARTED_0_1_1), Some(("taskrun","started"))); // // assert_eq!(extract_subject_predicate(TASKRUN_STARTED_0_2_0), Some(("taskrun","started"))); // +// assert_eq!(extract_subject_predicate(TESTCASERUN_FINISHED_0_3_0), Some(("testcaserun","finished"))); +// // assert_eq!(extract_subject_predicate(TESTCASERUN_FINISHED_0_1_0), Some(("testcaserun","finished"))); // // assert_eq!(extract_subject_predicate(TESTCASERUN_FINISHED_0_2_0), Some(("testcaserun","finished"))); // +// assert_eq!(extract_subject_predicate(TESTCASERUN_QUEUED_0_3_0), Some(("testcaserun","queued"))); +// // assert_eq!(extract_subject_predicate(TESTCASERUN_QUEUED_0_1_0), Some(("testcaserun","queued"))); // // assert_eq!(extract_subject_predicate(TESTCASERUN_QUEUED_0_2_0), Some(("testcaserun","queued"))); // +// assert_eq!(extract_subject_predicate(TESTCASERUN_SKIPPED_0_2_0), Some(("testcaserun","skipped"))); +// // assert_eq!(extract_subject_predicate(TESTCASERUN_SKIPPED_0_1_0), Some(("testcaserun","skipped"))); // +// assert_eq!(extract_subject_predicate(TESTCASERUN_STARTED_0_3_0), Some(("testcaserun","started"))); +// // assert_eq!(extract_subject_predicate(TESTCASERUN_STARTED_0_1_0), Some(("testcaserun","started"))); // // assert_eq!(extract_subject_predicate(TESTCASERUN_STARTED_0_2_0), Some(("testcaserun","started"))); // +// assert_eq!(extract_subject_predicate(TESTOUTPUT_PUBLISHED_0_3_0), Some(("testoutput","published"))); +// // assert_eq!(extract_subject_predicate(TESTOUTPUT_PUBLISHED_0_1_0), Some(("testoutput","published"))); // // assert_eq!(extract_subject_predicate(TESTOUTPUT_PUBLISHED_0_2_0), Some(("testoutput","published"))); // +// assert_eq!(extract_subject_predicate(TESTSUITERUN_FINISHED_0_3_0), Some(("testsuiterun","finished"))); +// // assert_eq!(extract_subject_predicate(TESTSUITERUN_FINISHED_0_1_0), Some(("testsuiterun","finished"))); // // assert_eq!(extract_subject_predicate(TESTSUITERUN_FINISHED_0_2_0), Some(("testsuiterun","finished"))); // +// assert_eq!(extract_subject_predicate(TESTSUITERUN_QUEUED_0_3_0), Some(("testsuiterun","queued"))); +// // assert_eq!(extract_subject_predicate(TESTSUITERUN_QUEUED_0_1_0), Some(("testsuiterun","queued"))); // // assert_eq!(extract_subject_predicate(TESTSUITERUN_QUEUED_0_2_0), Some(("testsuiterun","queued"))); // +// assert_eq!(extract_subject_predicate(TESTSUITERUN_STARTED_0_3_0), Some(("testsuiterun","started"))); +// // assert_eq!(extract_subject_predicate(TESTSUITERUN_STARTED_0_1_0), Some(("testsuiterun","started"))); // // assert_eq!(extract_subject_predicate(TESTSUITERUN_STARTED_0_2_0), Some(("testsuiterun","started"))); // +// assert_eq!(extract_subject_predicate(TICKET_CLOSED_0_2_0), Some(("ticket","closed"))); +// // assert_eq!(extract_subject_predicate(TICKET_CLOSED_0_1_0), Some(("ticket","closed"))); // +// assert_eq!(extract_subject_predicate(TICKET_CREATED_0_2_0), Some(("ticket","created"))); +// // assert_eq!(extract_subject_predicate(TICKET_CREATED_0_1_0), Some(("ticket","created"))); // +// assert_eq!(extract_subject_predicate(TICKET_UPDATED_0_2_0), Some(("ticket","updated"))); +// // assert_eq!(extract_subject_predicate(TICKET_UPDATED_0_1_0), Some(("ticket","updated"))); // // } diff --git a/cdevents-sdk/src/generated/pipelinerun_finished_0_3_0.rs b/cdevents-sdk/src/generated/pipelinerun_finished_0_3_0.rs new file mode 100644 index 0000000..d87c25d --- /dev/null +++ b/cdevents-sdk/src/generated/pipelinerun_finished_0_3_0.rs @@ -0,0 +1,48 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "errors", default, skip_serializing_if = "Option::is_none",)] + pub errors: Option, + #[serde(rename = "outcome", default, skip_serializing_if = "Option::is_none",)] + pub outcome: Option, + #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none",)] + pub pipeline_name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentOutcome { + #[serde(rename = "success")] + Success, + #[serde(rename = "failure")] + Failure, + #[serde(rename = "cancel")] + Cancel, + #[serde(rename = "error")] + Error, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/pipelinerun_queued_0_3_0.rs b/cdevents-sdk/src/generated/pipelinerun_queued_0_3_0.rs new file mode 100644 index 0000000..f403410 --- /dev/null +++ b/cdevents-sdk/src/generated/pipelinerun_queued_0_3_0.rs @@ -0,0 +1,31 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none",)] + pub pipeline_name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/pipelinerun_started_0_3_0.rs b/cdevents-sdk/src/generated/pipelinerun_started_0_3_0.rs new file mode 100644 index 0000000..38c57ff --- /dev/null +++ b/cdevents-sdk/src/generated/pipelinerun_started_0_3_0.rs @@ -0,0 +1,31 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "pipelineName",)] + pub pipeline_name: String, + #[serde(rename = "uri",)] + pub uri: crate::Uri, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/repository_created_0_3_0.rs b/cdevents-sdk/src/generated/repository_created_0_3_0.rs new file mode 100644 index 0000000..3e2adc5 --- /dev/null +++ b/cdevents-sdk/src/generated/repository_created_0_3_0.rs @@ -0,0 +1,35 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "name",)] + pub name: crate::Name, + #[serde(rename = "owner", default, skip_serializing_if = "Option::is_none",)] + pub owner: Option, + #[serde(rename = "uri",)] + pub uri: crate::Uri, + #[serde(rename = "viewUrl", default, skip_serializing_if = "Option::is_none",)] + pub view_url: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/repository_deleted_0_3_0.rs b/cdevents-sdk/src/generated/repository_deleted_0_3_0.rs new file mode 100644 index 0000000..3538e08 --- /dev/null +++ b/cdevents-sdk/src/generated/repository_deleted_0_3_0.rs @@ -0,0 +1,35 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "owner", default, skip_serializing_if = "Option::is_none",)] + pub owner: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "viewUrl", default, skip_serializing_if = "Option::is_none",)] + pub view_url: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/repository_modified_0_3_0.rs b/cdevents-sdk/src/generated/repository_modified_0_3_0.rs new file mode 100644 index 0000000..3538e08 --- /dev/null +++ b/cdevents-sdk/src/generated/repository_modified_0_3_0.rs @@ -0,0 +1,35 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "owner", default, skip_serializing_if = "Option::is_none",)] + pub owner: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "viewUrl", default, skip_serializing_if = "Option::is_none",)] + pub view_url: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/service_deployed_0_3_0.rs b/cdevents-sdk/src/generated/service_deployed_0_3_0.rs new file mode 100644 index 0000000..b9fe280 --- /dev/null +++ b/cdevents-sdk/src/generated/service_deployed_0_3_0.rs @@ -0,0 +1,41 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "artifactId",)] + pub artifact_id: crate::Id, + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/service_published_0_3_0.rs b/cdevents-sdk/src/generated/service_published_0_3_0.rs new file mode 100644 index 0000000..e458076 --- /dev/null +++ b/cdevents-sdk/src/generated/service_published_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment", default, skip_serializing_if = "Option::is_none",)] + pub environment: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/service_removed_0_3_0.rs b/cdevents-sdk/src/generated/service_removed_0_3_0.rs new file mode 100644 index 0000000..e458076 --- /dev/null +++ b/cdevents-sdk/src/generated/service_removed_0_3_0.rs @@ -0,0 +1,39 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment", default, skip_serializing_if = "Option::is_none",)] + pub environment: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/service_rolledback_0_3_0.rs b/cdevents-sdk/src/generated/service_rolledback_0_3_0.rs new file mode 100644 index 0000000..b9fe280 --- /dev/null +++ b/cdevents-sdk/src/generated/service_rolledback_0_3_0.rs @@ -0,0 +1,41 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "artifactId",)] + pub artifact_id: crate::Id, + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/service_upgraded_0_3_0.rs b/cdevents-sdk/src/generated/service_upgraded_0_3_0.rs new file mode 100644 index 0000000..b9fe280 --- /dev/null +++ b/cdevents-sdk/src/generated/service_upgraded_0_3_0.rs @@ -0,0 +1,41 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "artifactId",)] + pub artifact_id: crate::Id, + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/taskrun_finished_0_3_0.rs b/cdevents-sdk/src/generated/taskrun_finished_0_3_0.rs new file mode 100644 index 0000000..2f98f32 --- /dev/null +++ b/cdevents-sdk/src/generated/taskrun_finished_0_3_0.rs @@ -0,0 +1,47 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "errors", default, skip_serializing_if = "Option::is_none",)] + pub errors: Option, + #[serde(rename = "outcome", default, skip_serializing_if = "Option::is_none",)] + pub outcome: Option, + #[serde(rename = "pipelineRun", default, skip_serializing_if = "Option::is_none",)] + pub pipeline_run: Option, + #[serde(rename = "taskName", default, skip_serializing_if = "Option::is_none",)] + pub task_name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentPipelineRun { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/taskrun_started_0_3_0.rs b/cdevents-sdk/src/generated/taskrun_started_0_3_0.rs new file mode 100644 index 0000000..612a9e7 --- /dev/null +++ b/cdevents-sdk/src/generated/taskrun_started_0_3_0.rs @@ -0,0 +1,43 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "pipelineRun", default, skip_serializing_if = "Option::is_none",)] + pub pipeline_run: Option, + #[serde(rename = "taskName", default, skip_serializing_if = "Option::is_none",)] + pub task_name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentPipelineRun { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testcaserun_finished_0_3_0.rs b/cdevents-sdk/src/generated/testcaserun_finished_0_3_0.rs new file mode 100644 index 0000000..7082dab --- /dev/null +++ b/cdevents-sdk/src/generated/testcaserun_finished_0_3_0.rs @@ -0,0 +1,122 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "outcome",)] + pub outcome: ContentOutcome, + #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none",)] + pub reason: Option, + #[serde(rename = "severity", default, skip_serializing_if = "Option::is_none",)] + pub severity: Option, + #[serde(rename = "testCase", default, skip_serializing_if = "Option::is_none",)] + pub test_case: Option, + #[serde(rename = "testSuiteRun", default, skip_serializing_if = "Option::is_none",)] + pub test_suite_run: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestSuiteRun { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestCase { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "version", default, skip_serializing_if = "Option::is_none",)] + pub version: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentOutcome { + #[serde(rename = "success")] + Success, + #[serde(rename = "failure")] + Failure, + #[serde(rename = "cancel")] + Cancel, + #[serde(rename = "error")] + Error, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentSeverity { + #[serde(rename = "low")] + Low, + #[serde(rename = "medium")] + Medium, + #[serde(rename = "high")] + High, + #[serde(rename = "critical")] + Critical, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTestCaseType { + #[serde(rename = "performance")] + Performance, + #[serde(rename = "functional")] + Functional, + #[serde(rename = "unit")] + Unit, + #[serde(rename = "security")] + Security, + #[serde(rename = "compliance")] + Compliance, + #[serde(rename = "integration")] + Integration, + #[serde(rename = "e2e")] + E2E, + #[serde(rename = "other")] + Other, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testcaserun_queued_0_3_0.rs b/cdevents-sdk/src/generated/testcaserun_queued_0_3_0.rs new file mode 100644 index 0000000..3c5c12c --- /dev/null +++ b/cdevents-sdk/src/generated/testcaserun_queued_0_3_0.rs @@ -0,0 +1,117 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "testCase", default, skip_serializing_if = "Option::is_none",)] + pub test_case: Option, + #[serde(rename = "testSuiteRun", default, skip_serializing_if = "Option::is_none",)] + pub test_suite_run: Option, + #[serde(rename = "trigger", default, skip_serializing_if = "Option::is_none",)] + pub trigger: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTrigger { + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestSuiteRun { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestCase { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "version", default, skip_serializing_if = "Option::is_none",)] + pub version: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTestCaseType { + #[serde(rename = "performance")] + Performance, + #[serde(rename = "functional")] + Functional, + #[serde(rename = "unit")] + Unit, + #[serde(rename = "security")] + Security, + #[serde(rename = "compliance")] + Compliance, + #[serde(rename = "integration")] + Integration, + #[serde(rename = "e2e")] + E2E, + #[serde(rename = "other")] + Other, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTriggerType { + #[serde(rename = "manual")] + Manual, + #[serde(rename = "pipeline")] + Pipeline, + #[serde(rename = "event")] + Event, + #[serde(rename = "schedule")] + Schedule, + #[serde(rename = "other")] + Other, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testcaserun_skipped_0_2_0.rs b/cdevents-sdk/src/generated/testcaserun_skipped_0_2_0.rs new file mode 100644 index 0000000..e862a84 --- /dev/null +++ b/cdevents-sdk/src/generated/testcaserun_skipped_0_2_0.rs @@ -0,0 +1,92 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment", default, skip_serializing_if = "Option::is_none",)] + pub environment: Option, + #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none",)] + pub reason: Option, + #[serde(rename = "testCase", default, skip_serializing_if = "Option::is_none",)] + pub test_case: Option, + #[serde(rename = "testSuiteRun", default, skip_serializing_if = "Option::is_none",)] + pub test_suite_run: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestSuiteRun { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestCase { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "version", default, skip_serializing_if = "Option::is_none",)] + pub version: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTestCaseType { + #[serde(rename = "performance")] + Performance, + #[serde(rename = "functional")] + Functional, + #[serde(rename = "unit")] + Unit, + #[serde(rename = "security")] + Security, + #[serde(rename = "compliance")] + Compliance, + #[serde(rename = "integration")] + Integration, + #[serde(rename = "e2e")] + E2E, + #[serde(rename = "other")] + Other, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testcaserun_started_0_3_0.rs b/cdevents-sdk/src/generated/testcaserun_started_0_3_0.rs new file mode 100644 index 0000000..3c5c12c --- /dev/null +++ b/cdevents-sdk/src/generated/testcaserun_started_0_3_0.rs @@ -0,0 +1,117 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "testCase", default, skip_serializing_if = "Option::is_none",)] + pub test_case: Option, + #[serde(rename = "testSuiteRun", default, skip_serializing_if = "Option::is_none",)] + pub test_suite_run: Option, + #[serde(rename = "trigger", default, skip_serializing_if = "Option::is_none",)] + pub trigger: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTrigger { + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestSuiteRun { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestCase { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "version", default, skip_serializing_if = "Option::is_none",)] + pub version: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTestCaseType { + #[serde(rename = "performance")] + Performance, + #[serde(rename = "functional")] + Functional, + #[serde(rename = "unit")] + Unit, + #[serde(rename = "security")] + Security, + #[serde(rename = "compliance")] + Compliance, + #[serde(rename = "integration")] + Integration, + #[serde(rename = "e2e")] + E2E, + #[serde(rename = "other")] + Other, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTriggerType { + #[serde(rename = "manual")] + Manual, + #[serde(rename = "pipeline")] + Pipeline, + #[serde(rename = "event")] + Event, + #[serde(rename = "schedule")] + Schedule, + #[serde(rename = "other")] + Other, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testoutput_published_0_3_0.rs b/cdevents-sdk/src/generated/testoutput_published_0_3_0.rs new file mode 100644 index 0000000..b4a146a --- /dev/null +++ b/cdevents-sdk/src/generated/testoutput_published_0_3_0.rs @@ -0,0 +1,60 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "format",)] + pub format: String, + #[serde(rename = "outputType",)] + pub output_type: ContentOutputType, + #[serde(rename = "testCaseRun", default, skip_serializing_if = "Option::is_none",)] + pub test_case_run: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestCaseRun { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentOutputType { + #[serde(rename = "report")] + Report, + #[serde(rename = "video")] + Video, + #[serde(rename = "image")] + Image, + #[serde(rename = "log")] + Log, + #[serde(rename = "other")] + Other, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testsuiterun_finished_0_3_0.rs b/cdevents-sdk/src/generated/testsuiterun_finished_0_3_0.rs new file mode 100644 index 0000000..859489e --- /dev/null +++ b/cdevents-sdk/src/generated/testsuiterun_finished_0_3_0.rs @@ -0,0 +1,87 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "outcome",)] + pub outcome: ContentOutcome, + #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none",)] + pub reason: Option, + #[serde(rename = "severity", default, skip_serializing_if = "Option::is_none",)] + pub severity: Option, + #[serde(rename = "testSuite", default, skip_serializing_if = "Option::is_none",)] + pub test_suite: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestSuite { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "version", default, skip_serializing_if = "Option::is_none",)] + pub version: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentOutcome { + #[serde(rename = "success")] + Success, + #[serde(rename = "failure")] + Failure, + #[serde(rename = "cancel")] + Cancel, + #[serde(rename = "error")] + Error, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentSeverity { + #[serde(rename = "low")] + Low, + #[serde(rename = "medium")] + Medium, + #[serde(rename = "high")] + High, + #[serde(rename = "critical")] + Critical, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testsuiterun_queued_0_3_0.rs b/cdevents-sdk/src/generated/testsuiterun_queued_0_3_0.rs new file mode 100644 index 0000000..9c27a7d --- /dev/null +++ b/cdevents-sdk/src/generated/testsuiterun_queued_0_3_0.rs @@ -0,0 +1,82 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "testSuite", default, skip_serializing_if = "Option::is_none",)] + pub test_suite: Option, + #[serde(rename = "trigger", default, skip_serializing_if = "Option::is_none",)] + pub trigger: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTrigger { + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestSuite { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "version", default, skip_serializing_if = "Option::is_none",)] + pub version: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTriggerType { + #[serde(rename = "manual")] + Manual, + #[serde(rename = "pipeline")] + Pipeline, + #[serde(rename = "event")] + Event, + #[serde(rename = "schedule")] + Schedule, + #[serde(rename = "other")] + Other, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/testsuiterun_started_0_3_0.rs b/cdevents-sdk/src/generated/testsuiterun_started_0_3_0.rs new file mode 100644 index 0000000..9c27a7d --- /dev/null +++ b/cdevents-sdk/src/generated/testsuiterun_started_0_3_0.rs @@ -0,0 +1,82 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "environment",)] + pub environment: ContentEnvironment, + #[serde(rename = "testSuite", default, skip_serializing_if = "Option::is_none",)] + pub test_suite: Option, + #[serde(rename = "trigger", default, skip_serializing_if = "Option::is_none",)] + pub trigger: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTrigger { + #[serde(rename = "type", default, skip_serializing_if = "Option::is_none",)] + pub ty: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentTestSuite { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none",)] + pub name: Option, + #[serde(rename = "uri", default, skip_serializing_if = "Option::is_none",)] + pub uri: Option, + #[serde(rename = "version", default, skip_serializing_if = "Option::is_none",)] + pub version: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct ContentEnvironment { + #[serde(rename = "id",)] + pub id: crate::Id, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none",)] + pub source: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +pub enum ContentTriggerType { + #[serde(rename = "manual")] + Manual, + #[serde(rename = "pipeline")] + Pipeline, + #[serde(rename = "event")] + Event, + #[serde(rename = "schedule")] + Schedule, + #[serde(rename = "other")] + Other, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/ticket_closed_0_2_0.rs b/cdevents-sdk/src/generated/ticket_closed_0_2_0.rs new file mode 100644 index 0000000..cf91071 --- /dev/null +++ b/cdevents-sdk/src/generated/ticket_closed_0_2_0.rs @@ -0,0 +1,49 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "assignees", default, skip_serializing_if = "Option::is_none",)] + pub assignees: Option>, + #[serde(rename = "creator", default, skip_serializing_if = "Option::is_none",)] + pub creator: Option, + #[serde(rename = "group", default, skip_serializing_if = "Option::is_none",)] + pub group: Option, + #[serde(rename = "labels", default, skip_serializing_if = "Option::is_none",)] + pub labels: Option>, + #[serde(rename = "milestone", default, skip_serializing_if = "Option::is_none",)] + pub milestone: Option, + #[serde(rename = "priority", default, skip_serializing_if = "Option::is_none",)] + pub priority: Option, + #[serde(rename = "resolution",)] + pub resolution: crate::NonEmptyString, + #[serde(rename = "summary", default, skip_serializing_if = "Option::is_none",)] + pub summary: Option, + #[serde(rename = "ticketType", default, skip_serializing_if = "Option::is_none",)] + pub ticket_type: Option, + #[serde(rename = "updatedBy", default, skip_serializing_if = "Option::is_none",)] + pub updated_by: Option, + #[serde(rename = "uri",)] + pub uri: crate::UriReference, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/ticket_created_0_2_0.rs b/cdevents-sdk/src/generated/ticket_created_0_2_0.rs new file mode 100644 index 0000000..9455f02 --- /dev/null +++ b/cdevents-sdk/src/generated/ticket_created_0_2_0.rs @@ -0,0 +1,45 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "assignees", default, skip_serializing_if = "Option::is_none",)] + pub assignees: Option>, + #[serde(rename = "creator",)] + pub creator: crate::NonEmptyString, + #[serde(rename = "group", default, skip_serializing_if = "Option::is_none",)] + pub group: Option, + #[serde(rename = "labels", default, skip_serializing_if = "Option::is_none",)] + pub labels: Option>, + #[serde(rename = "milestone", default, skip_serializing_if = "Option::is_none",)] + pub milestone: Option, + #[serde(rename = "priority", default, skip_serializing_if = "Option::is_none",)] + pub priority: Option, + #[serde(rename = "summary",)] + pub summary: String, + #[serde(rename = "ticketType", default, skip_serializing_if = "Option::is_none",)] + pub ticket_type: Option, + #[serde(rename = "uri",)] + pub uri: crate::UriReference, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/generated/ticket_updated_0_2_0.rs b/cdevents-sdk/src/generated/ticket_updated_0_2_0.rs new file mode 100644 index 0000000..6518119 --- /dev/null +++ b/cdevents-sdk/src/generated/ticket_updated_0_2_0.rs @@ -0,0 +1,47 @@ +// @generated +// by cdevents/sdk-rust/generator (subject.hbs) + +#[cfg(feature = "testkit")] use proptest_derive::Arbitrary; +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[cfg_attr(feature = "testkit", derive(Arbitrary))] +#[serde(deny_unknown_fields)] +pub struct Content { + #[serde(rename = "assignees", default, skip_serializing_if = "Option::is_none",)] + pub assignees: Option>, + #[serde(rename = "creator", default, skip_serializing_if = "Option::is_none",)] + pub creator: Option, + #[serde(rename = "group", default, skip_serializing_if = "Option::is_none",)] + pub group: Option, + #[serde(rename = "labels", default, skip_serializing_if = "Option::is_none",)] + pub labels: Option>, + #[serde(rename = "milestone", default, skip_serializing_if = "Option::is_none",)] + pub milestone: Option, + #[serde(rename = "priority", default, skip_serializing_if = "Option::is_none",)] + pub priority: Option, + #[serde(rename = "summary", default, skip_serializing_if = "Option::is_none",)] + pub summary: Option, + #[serde(rename = "ticketType", default, skip_serializing_if = "Option::is_none",)] + pub ticket_type: Option, + #[serde(rename = "updatedBy", default, skip_serializing_if = "Option::is_none",)] + pub updated_by: Option, + #[serde(rename = "uri",)] + pub uri: crate::UriReference, +} + +#[cfg(test)] +mod tests { + use proptest::prelude::*; + use super::*; + + proptest! { + #[test] + #[cfg(feature = "testkit")] + fn arbitraries_are_json_valid(s in any::()) { + let json_str = serde_json::to_string(&s).unwrap(); + let actual = serde_json::from_str::(&json_str).unwrap(); + assert_eq!(s, actual); + } + } +} diff --git a/cdevents-sdk/src/subject.rs b/cdevents-sdk/src/subject.rs index f120a4f..299d5d2 100644 --- a/cdevents-sdk/src/subject.rs +++ b/cdevents-sdk/src/subject.rs @@ -18,8 +18,10 @@ pub struct Subject { skip_serializing_if = "Option::is_none", )] source: Option, - #[serde(rename = "type")] - ty: String, + #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)] + #[deprecated = "this file was removed since cdevents spec 0.5"] + #[doc(hidden)] + ty: Option, } impl Subject { @@ -43,17 +45,18 @@ impl Subject { self } - /// see - /// derived from content - pub fn ty(&self) -> &str { - &self.ty - } + // /// see + // /// derived from content + // pub fn ty(&self) -> &str { + // &self.ty + // } /// see pub fn content(&self) -> &Content { &self.content } + #[allow(deprecated)] pub fn from_json(ty: &str, json: serde_json::Value) -> Result { Ok(Subject { id: json["id"] @@ -62,9 +65,7 @@ impl Subject { .try_into() .map_err(serde::de::Error::custom)?, ty: json["type"] - .as_str() - .ok_or_else(|| serde::de::Error::missing_field("type"))? - .to_string(), + .as_str().map(|s| s.to_owned()), source: match json["source"].as_str() { None => None, Some(s) => Some( @@ -77,12 +78,12 @@ impl Subject { } impl From for Subject where T: Into{ + #[allow(deprecated)] fn from(content: T) -> Self { let content = content.into(); + // TODO remove this hack when remove support for spec < 0.5 let ty = crate::extract_subject_predicate(content.ty()) - .map(|(s, _)| s) - .unwrap_or("unknown") - .to_owned(); + .map(|(s, _)| s.to_string()); Self { content, id: Id::default(), @@ -127,4 +128,4 @@ mod tests { serde_json::to_string(&s).unwrap(); } } -} \ No newline at end of file +} diff --git a/cdevents-specs/main b/cdevents-specs/main index b02be28..e11db2f 160000 --- a/cdevents-specs/main +++ b/cdevents-specs/main @@ -1 +1 @@ -Subproject commit b02be288bfa24c487f74a711f7acae45c9c6dc2d +Subproject commit e11db2f7c96b0665ce80c860314441858e9c2c1e diff --git a/cdevents-specs/spec-v0.5 b/cdevents-specs/spec-v0.5 new file mode 160000 index 0000000..8e09a2d --- /dev/null +++ b/cdevents-specs/spec-v0.5 @@ -0,0 +1 @@ +Subproject commit 8e09a2dcde760d0cfac674cc703df4ca7236d4ab diff --git a/generator/Cargo.toml b/generator/Cargo.toml index 86958cb..950968d 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -2,7 +2,6 @@ [package] name = "generator" version.workspace = true -authors.workspace = true edition.workspace = true license.workspace = true publish = false diff --git a/generator/templates/mod.hbs b/generator/templates/mod.hbs index d9cb755..0704274 100644 --- a/generator/templates/mod.hbs +++ b/generator/templates/mod.hbs @@ -87,12 +87,31 @@ pub fn extract_subject_predicate(ty: &str) -> Option<(&str, &str)>{ // let mut split = ty.split('.'); match ty { {{#each variants }} + {{#if (or (eq this.spec_version "0.4.1") (eq this.spec_version "0.4.0") (eq this.spec_version "0.3.0")) }} {{to_screaming_snake_case this.rust_module}} => Some(("{{ this.subject_type }}", "{{ this.predicate }}")), + {{/if}} {{/each}} _ => None, } } +/// Due to inconstency in case/format the subject could be not be extracted from the context.type (ty), jsonshema $id, spec filename (shema, examples) +/// Custom type are not supported +pub(crate) fn new_context(ty: &str) -> crate::context::ContextEnum { + use crate::context::{ContextEnum, Context_0_3, Context_0_4, Context_0_5}; + match ty { + {{#each variants }} + {{#if (eq this.spec_version "0.3.0") }} + {{to_screaming_snake_case this.rust_module}} => ContextEnum::Context_0_3(Context_0_3::new(ty.into())), + {{/if}} + {{#if (or (eq this.spec_version "0.4.1") (eq this.spec_version "0.4.0")) }} + {{to_screaming_snake_case this.rust_module}} => ContextEnum::Context_0_4(Context_0_4::new(ty.into())), + {{/if}} + {{/each}} + _ => ContextEnum::Context_0_5(Context_0_5::new(ty.into())), + } +} + {{#each variants }} impl From<{{this.rust_module}}::Content> for Content { fn from(value: {{this.rust_module}}::Content) -> Self { diff --git a/rust-toolchain.toml b/rust-toolchain.toml index b07a9c0..3520d84 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,4 +1,4 @@ [toolchain] -channel = "1.85.0" +channel = "1.93.1" components = ["rustc", "cargo", "rust-std", "clippy", "rustfmt"] profile = "minimal" diff --git a/types/Cargo.toml b/types/Cargo.toml deleted file mode 100644 index d5e7271..0000000 --- a/types/Cargo.toml +++ /dev/null @@ -1,9 +0,0 @@ -[package] -name = "types" -version = "0.1.0" -edition = "2021" -license = "MIT" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[dependencies] diff --git a/types/src/main.rs b/types/src/main.rs deleted file mode 100644 index e7a11a9..0000000 --- a/types/src/main.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() { - println!("Hello, world!"); -}