From 336350fbb4bc9d0fed49bf7f2ad142c6d40a8f27 Mon Sep 17 00:00:00 2001 From: Nisarg Thakkar Date: Sat, 13 May 2017 23:10:31 +0530 Subject: [PATCH 1/3] Added badges for Is it maintained, codecov and coveralls --- app/components/badge-codecov.js | 16 +++ app/components/badge-coveralls.js | 16 +++ ...badge-is-it-maintained-issue-resolution.js | 10 ++ .../badge-is-it-maintained-open-issues.js | 10 ++ app/templates/components/badge-codecov.hbs | 6 + app/templates/components/badge-coveralls.hbs | 6 + ...adge-is-it-maintained-issue-resolution.hbs | 6 + .../badge-is-it-maintained-open-issues.hbs | 6 + mirage/fixtures/search.js | 26 ++++ src/badge.rs | 20 +++ src/tests/badge.rs | 118 ++++++++++++++++++ tests/acceptance/search-test.js | 16 ++- 12 files changed, 252 insertions(+), 4 deletions(-) create mode 100644 app/components/badge-codecov.js create mode 100644 app/components/badge-coveralls.js create mode 100644 app/components/badge-is-it-maintained-issue-resolution.js create mode 100644 app/components/badge-is-it-maintained-open-issues.js create mode 100644 app/templates/components/badge-codecov.hbs create mode 100644 app/templates/components/badge-coveralls.hbs create mode 100644 app/templates/components/badge-is-it-maintained-issue-resolution.hbs create mode 100644 app/templates/components/badge-is-it-maintained-open-issues.hbs diff --git a/app/components/badge-codecov.js b/app/components/badge-codecov.js new file mode 100644 index 00000000000..320e219341d --- /dev/null +++ b/app/components/badge-codecov.js @@ -0,0 +1,16 @@ +import Ember from 'ember'; + +export default Ember.Component.extend({ + tagName: 'span', + classNames: ['badge'], + repository: Ember.computed.alias('badge.attributes.repository'), + branch: Ember.computed('badge.attributes.branch', function() { + return this.get('badge.attributes.branch') || 'master'; + }), + service: Ember.computed('badge.attributes.service', function() { + return this.get('badge.attributes.service') || 'github'; + }), + text: Ember.computed('branch', function() { + return `CodeCov coverage status for the ${ this.get('branch') } branch`; + }) +}); diff --git a/app/components/badge-coveralls.js b/app/components/badge-coveralls.js new file mode 100644 index 00000000000..fd860c30f9c --- /dev/null +++ b/app/components/badge-coveralls.js @@ -0,0 +1,16 @@ +import Ember from 'ember'; + +export default Ember.Component.extend({ + tagName: 'span', + classNames: ['badge'], + repository: Ember.computed.alias('badge.attributes.repository'), + branch: Ember.computed('badge.attributes.branch', function() { + return this.get('badge.attributes.branch') || 'master'; + }), + service: Ember.computed('badge.attributes.service', function() { + return this.get('badge.attributes.service') || 'github'; + }), + text: Ember.computed('branch', function() { + return `Coveralls coverage status for the ${ this.get('branch') } branch`; + }) +}); diff --git a/app/components/badge-is-it-maintained-issue-resolution.js b/app/components/badge-is-it-maintained-issue-resolution.js new file mode 100644 index 00000000000..fd535823759 --- /dev/null +++ b/app/components/badge-is-it-maintained-issue-resolution.js @@ -0,0 +1,10 @@ +import Ember from 'ember'; + +export default Ember.Component.extend({ + tagName: 'span', + classNames: ['badge'], + repository: Ember.computed.alias('badge.attributes.repository'), + text: Ember.computed('badge', function() { + return `Is It Maintained average time to resolve an issue`; + }) +}); \ No newline at end of file diff --git a/app/components/badge-is-it-maintained-open-issues.js b/app/components/badge-is-it-maintained-open-issues.js new file mode 100644 index 00000000000..830dcafd1ee --- /dev/null +++ b/app/components/badge-is-it-maintained-open-issues.js @@ -0,0 +1,10 @@ +import Ember from 'ember'; + +export default Ember.Component.extend({ + tagName: 'span', + classNames: ['badge'], + repository: Ember.computed.alias('badge.attributes.repository'), + text: Ember.computed('badge', function() { + return `Is It Maintained percentage of issues still open`; + }) +}); diff --git a/app/templates/components/badge-codecov.hbs b/app/templates/components/badge-codecov.hbs new file mode 100644 index 00000000000..0f1b346226a --- /dev/null +++ b/app/templates/components/badge-codecov.hbs @@ -0,0 +1,6 @@ + + {{ text }} + \ No newline at end of file diff --git a/app/templates/components/badge-coveralls.hbs b/app/templates/components/badge-coveralls.hbs new file mode 100644 index 00000000000..a0a8ededf7a --- /dev/null +++ b/app/templates/components/badge-coveralls.hbs @@ -0,0 +1,6 @@ + + {{ text }} + \ No newline at end of file diff --git a/app/templates/components/badge-is-it-maintained-issue-resolution.hbs b/app/templates/components/badge-is-it-maintained-issue-resolution.hbs new file mode 100644 index 00000000000..d824cf4aaed --- /dev/null +++ b/app/templates/components/badge-is-it-maintained-issue-resolution.hbs @@ -0,0 +1,6 @@ + + {{ text }} + diff --git a/app/templates/components/badge-is-it-maintained-open-issues.hbs b/app/templates/components/badge-is-it-maintained-open-issues.hbs new file mode 100644 index 00000000000..a10cfd1a4f2 --- /dev/null +++ b/app/templates/components/badge-is-it-maintained-open-issues.hbs @@ -0,0 +1,6 @@ + + {{ text }} + diff --git a/mirage/fixtures/search.js b/mirage/fixtures/search.js index 263e0e1373a..3fc3a403f3a 100644 --- a/mirage/fixtures/search.js +++ b/mirage/fixtures/search.js @@ -40,6 +40,32 @@ export default { "repository": "huonw/external_mixin" }, "badge_type": "gitlab" + }, + { + "attributes": { + "repository": "huonw/external_mixin" + }, + "badge_type": "is-it-maintained-issue-resolution" + }, + { + "attributes": { + "repository": "huonw/external_mixin" + }, + "badge_type": "is-it-maintained-open-issues" + }, + { + "attributes": { + "branch": "master", + "repository": "huonw/external_mixin" + }, + "badge_type": "codecov" + }, + { + "attributes": { + "branch": "master", + "repository": "huonw/external_mixin" + }, + "badge_type": "coveralls" } ], "versions": null diff --git a/src/badge.rs b/src/badge.rs index 34e48536859..d14af51a4f4 100644 --- a/src/badge.rs +++ b/src/badge.rs @@ -25,6 +25,22 @@ pub enum Badge { GitLab { repository: String, branch: Option, }, + #[serde(rename = "is-it-maintained-issue-resolution")] + IsItMaintainedIssueResolution { + repository: String, + }, + #[serde(rename = "is-it-maintained-open-issues")] + IsItMaintainedOpenIssues { + repository: String, + }, + #[serde(rename = "codecov")] + CodeCov { + repository: String, branch: Option, service: Option, + }, + #[serde(rename = "coveralls")] + Coveralls { + repository: String, branch: Option, service: Option, + }, } #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug, Deserialize)] @@ -64,6 +80,10 @@ impl Badge { Badge::TravisCi {..} => "travis-ci", Badge::Appveyor {..} => "appveyor", Badge::GitLab{..} => "gitlab", + Badge::IsItMaintainedIssueResolution{..} => "is-it-maintained-issue-resolution", + Badge::IsItMaintainedOpenIssues{..} => "is-it-maintained-open-issues", + Badge::CodeCov{..} => "codecov", + Badge::Coveralls{..} => "coveralls", } } diff --git a/src/tests/badge.rs b/src/tests/badge.rs index 4425507f666..dafd024099a 100644 --- a/src/tests/badge.rs +++ b/src/tests/badge.rs @@ -14,6 +14,14 @@ struct BadgeRef { travis_ci_attributes: HashMap, gitlab: Badge, gitlab_attributes: HashMap, + isitmaintained_issue_resolution: Badge, + isitmaintained_issue_resolution_attributes: HashMap, + isitmaintained_open_issues: Badge, + isitmaintained_open_issues_attributes: HashMap, + codecov: Badge, + codecov_attributes: HashMap, + coveralls: Badge, + coveralls_attributes: HashMap, } fn set_up() -> (MockRequest, Crate, BadgeRef) { @@ -66,6 +74,52 @@ fn set_up() -> (MockRequest, Crate, BadgeRef) { String::from("rust-lang/rust") ); + let isitmaintained_issue_resolution = Badge::IsItMaintainedIssueResolution { + repository: String::from("rust-lang/rust"), + }; + let mut badge_attributes_isitmaintained_issue_resolution = HashMap::new(); + badge_attributes_isitmaintained_issue_resolution.insert( + String::from("repository"), + String::from("rust-lang/rust") + ); + + let isitmaintained_open_issues = Badge::IsItMaintainedOpenIssues { + repository: String::from("rust-lang/rust"), + }; + let mut badge_attributes_isitmaintained_open_issues = HashMap::new(); + badge_attributes_isitmaintained_open_issues.insert( + String::from("repository"), + String::from("rust-lang/rust") + ); + + let codecov = Badge::CodeCov { + branch: Some(String::from("beta")), + repository: String::from("rust-lang/rust"), + }; + let mut badge_attributes_codecov = HashMap::new(); + badge_attributes_codecov.insert( + String::from("branch"), + String::from("beta") + ); + badge_attributes_codecov.insert( + String::from("repository"), + String::from("rust-lang/rust") + ); + + let coveralls = Badge::Coveralls { + branch: Some(String::from("beta")), + repository: String::from("rust-lang/rust"), + }; + let mut badge_attributes_coveralls = HashMap::new(); + badge_attributes_coveralls.insert( + String::from("branch"), + String::from("beta") + ); + badge_attributes_coveralls.insert( + String::from("repository"), + String::from("rust-lang/rust") + ); + let badges = BadgeRef { appveyor: appveyor, appveyor_attributes: badge_attributes_appveyor, @@ -73,6 +127,14 @@ fn set_up() -> (MockRequest, Crate, BadgeRef) { travis_ci_attributes: badge_attributes_travis_ci, gitlab: gitlab, gitlab_attributes: badge_attributes_gitlab, + isitmaintained_issue_resolution: isitmaintained_issue_resolution, + isitmaintained_issue_resolution_attributes: badge_attributes_isitmaintained_issue_resolution, + isitmaintained_open_issues: isitmaintained_open_issues, + isitmaintained_open_issues_attributes: badge_attributes_isitmaintained_open_issues, + codecov: codecov, + codecov_attributes: badge_attributes_codecov, + coveralls: coveralls, + coveralls_attributes: badge_attributes_coveralls, }; (req, krate, badges) } @@ -131,6 +193,62 @@ fn update_add_gitlab() { assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.gitlab]); } +#[test] +fn update_add_isitmaintained_issue_resolution() { + // Add a isitmaintained_issue_resolution badge + let (req, krate, test_badges) = set_up(); + + let mut badges = HashMap::new(); + badges.insert( + String::from("is-it-maintained-issue-resolution"), + test_badges.isitmaintained_issue_resolution_attributes + ); + Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.isitmaintained_issue_resolution]); +} + +#[test] +fn update_add_isitmaintained_open_issues() { + // Add a isitmaintained_open_issues badge + let (req, krate, test_badges) = set_up(); + + let mut badges = HashMap::new(); + badges.insert( + String::from("is-it-maintained-open-issues"), + test_badges.isitmaintained_open_issues_attributes + ); + Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.isitmaintained_open_issues]); +} + +#[test] +fn update_add_codecov() { + // Add a codecov badge + let (req, krate, test_badges) = set_up(); + + let mut badges = HashMap::new(); + badges.insert( + String::from("codecov"), + test_badges.codecov_attributes + ); + Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.codecov]); +} + +#[test] +fn update_add_coveralls() { + // Add a coveralls badge + let (req, krate, test_badges) = set_up(); + + let mut badges = HashMap::new(); + badges.insert( + String::from("coveralls"), + test_badges.coveralls_attributes + ); + Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.coveralls]); +} + #[test] fn replace_badge() { // Replacing one badge with another diff --git a/tests/acceptance/search-test.js b/tests/acceptance/search-test.js index de40521e0bb..c9950b855b7 100644 --- a/tests/acceptance/search-test.js +++ b/tests/acceptance/search-test.js @@ -26,10 +26,18 @@ test('searching for "rust"', function(assert) { findWithAssert('#crates .row:first .desc .info .badge:first a[href="https://ci.appveyor.com/project/huonw/external_mixin"]'); findWithAssert('#crates .row:first .desc .info .badge:first a img[src="https://ci.appveyor.com/api/projects/status/github/huonw/external_mixin?svg=true&branch=master"]'); - findWithAssert('#crates .row:first .desc .info .badge:eq(1) a[href="https://gitlab.com/huonw/external_mixin/pipelines"]'); - findWithAssert('#crates .row:first .desc .info .badge:eq(1) a img[src="https://gitlab.com/huonw/external_mixin/badges/master/build.svg"]'); - findWithAssert('#crates .row:first .desc .info .badge:eq(2) a[href="https://travis-ci.org/huonw/external_mixin"]'); - findWithAssert('#crates .row:first .desc .info .badge:eq(2) a img[src="https://travis-ci.org/huonw/external_mixin.svg?branch=master"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(1) a[href="https://codecov.io/github/huonw/external_mixin?branch=master"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(1) a img[src="https://codecov.io/github/huonw/external_mixin/coverage.svg?branch=master"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(2) a[href="https://coveralls.io/github/huonw/external_mixin?branch=master"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(2) a img[src="https://coveralls.io/repos/github/huonw/external_mixin/badge.svg?branch=master"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(3) a[href="https://gitlab.com/huonw/external_mixin/pipelines"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(3) a img[src="https://gitlab.com/huonw/external_mixin/badges/master/build.svg"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(4) a[href="https://isitmaintained.com/project/huonw/external_mixin"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(4) a img[src="https://isitmaintained.com/badge/resolution/huonw/external_mixin.svg"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(5) a[href="https://isitmaintained.com/project/huonw/external_mixin"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(5) a img[src="https://isitmaintained.com/badge/open/huonw/external_mixin.svg"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(6) a[href="https://travis-ci.org/huonw/external_mixin"]'); + findWithAssert('#crates .row:first .desc .info .badge:eq(6) a img[src="https://travis-ci.org/huonw/external_mixin.svg?branch=master"]'); hasText(assert, '#crates .row:first .desc .summary', 'Yo dawg, use Rust to generate Rust, right in your Rust. (See `external_mixin` to use scripting languages.)'); hasText(assert, '#crates .row:first .downloads', '477'); From 0e210ea4cfaee5985f25860ff29c26aea4bbd379 Mon Sep 17 00:00:00 2001 From: Nisarg Thakkar Date: Sun, 14 May 2017 01:59:48 +0530 Subject: [PATCH 2/3] Fixing test case failures --- src/badge.rs | 4 +- src/tests/badge.rs | 92 +++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 93 insertions(+), 3 deletions(-) diff --git a/src/badge.rs b/src/badge.rs index d14af51a4f4..c74adb29af4 100644 --- a/src/badge.rs +++ b/src/badge.rs @@ -34,7 +34,7 @@ pub enum Badge { repository: String, }, #[serde(rename = "codecov")] - CodeCov { + Codecov { repository: String, branch: Option, service: Option, }, #[serde(rename = "coveralls")] @@ -82,7 +82,7 @@ impl Badge { Badge::GitLab{..} => "gitlab", Badge::IsItMaintainedIssueResolution{..} => "is-it-maintained-issue-resolution", Badge::IsItMaintainedOpenIssues{..} => "is-it-maintained-open-issues", - Badge::CodeCov{..} => "codecov", + Badge::Codecov{..} => "codecov", Badge::Coveralls{..} => "coveralls", } } diff --git a/src/tests/badge.rs b/src/tests/badge.rs index dafd024099a..259846d1e81 100644 --- a/src/tests/badge.rs +++ b/src/tests/badge.rs @@ -92,7 +92,8 @@ fn set_up() -> (MockRequest, Crate, BadgeRef) { String::from("rust-lang/rust") ); - let codecov = Badge::CodeCov { + let codecov = Badge::Codecov { + service: Some(String::from("github")), branch: Some(String::from("beta")), repository: String::from("rust-lang/rust"), }; @@ -105,8 +106,13 @@ fn set_up() -> (MockRequest, Crate, BadgeRef) { String::from("repository"), String::from("rust-lang/rust") ); + badge_attributes_codecov.insert( + String::from("service"), + String::from("github") + ); let coveralls = Badge::Coveralls { + service: Some(String::from("github")), branch: Some(String::from("beta")), repository: String::from("rust-lang/rust"), }; @@ -119,6 +125,10 @@ fn set_up() -> (MockRequest, Crate, BadgeRef) { String::from("repository"), String::from("rust-lang/rust") ); + badge_attributes_coveralls.insert( + String::from("service"), + String::from("github") + ); let badges = BadgeRef { appveyor: appveyor, @@ -406,6 +416,86 @@ fn gitlab_required_keys() { assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); } +#[test] +fn isitmaintained_issue_resolution_required_keys() { + // Add a isitmaintained_issue_resolution badge missing a required field + let (req, krate, mut test_badges) = set_up(); + + let mut badges = HashMap::new(); + + // Repository is a required key + test_badges.isitmaintained_issue_resolution_attributes.remove("repository"); + badges.insert( + String::from("isitmaintained_issue_resolution"), + test_badges.isitmaintained_issue_resolution_attributes + ); + + let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(invalid_badges.len(), 1); + assert!(invalid_badges.contains(&String::from("isitmaintained_issue_resolution"))); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); +} + +#[test] +fn isitmaintained_open_issues_required_keys() { + // Add a isitmaintained_open_issues badge missing a required field + let (req, krate, mut test_badges) = set_up(); + + let mut badges = HashMap::new(); + + // Repository is a required key + test_badges.isitmaintained_open_issues_attributes.remove("repository"); + badges.insert( + String::from("isitmaintained_open_issues"), + test_badges.isitmaintained_open_issues_attributes + ); + + let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(invalid_badges.len(), 1); + assert!(invalid_badges.contains(&String::from("isitmaintained_open_issues"))); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); +} + +#[test] +fn codecov_required_keys() { + // Add a codecov badge missing a required field + let (req, krate, mut test_badges) = set_up(); + + let mut badges = HashMap::new(); + + // Repository is a required key + test_badges.codecov_attributes.remove("repository"); + badges.insert( + String::from("codecov"), + test_badges.codecov_attributes + ); + + let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(invalid_badges.len(), 1); + assert!(invalid_badges.contains(&String::from("codecov"))); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); +} + +#[test] +fn coveralls_required_keys() { + // Add a coveralls badge missing a required field + let (req, krate, mut test_badges) = set_up(); + + let mut badges = HashMap::new(); + + // Repository is a required key + test_badges.coveralls_attributes.remove("repository"); + badges.insert( + String::from("coveralls"), + test_badges.coveralls_attributes + ); + + let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + assert_eq!(invalid_badges.len(), 1); + assert!(invalid_badges.contains(&String::from("coveralls"))); + assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); +} + #[test] fn unknown_badge() { // Add an unknown badge From 4274a18239331e24059d44be936c8b36225fdc58 Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Sun, 14 May 2017 10:08:06 -0400 Subject: [PATCH 3/3] Update tests to use diesel since badges now use diesel --- src/tests/badge.rs | 64 ++++++++++++++++++++++++++-------------------- 1 file changed, 36 insertions(+), 28 deletions(-) diff --git a/src/tests/badge.rs b/src/tests/badge.rs index b39234be0ac..5ca677fab0e 100644 --- a/src/tests/badge.rs +++ b/src/tests/badge.rs @@ -212,57 +212,61 @@ fn update_add_gitlab() { #[test] fn update_add_isitmaintained_issue_resolution() { // Add a isitmaintained_issue_resolution badge - let (req, krate, test_badges) = set_up(); + let (app, krate, test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); badges.insert( String::from("is-it-maintained-issue-resolution"), test_badges.isitmaintained_issue_resolution_attributes ); - Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.isitmaintained_issue_resolution]); + Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); + assert_eq!(krate.badges(&conn).unwrap(), vec![test_badges.isitmaintained_issue_resolution]); } #[test] fn update_add_isitmaintained_open_issues() { // Add a isitmaintained_open_issues badge - let (req, krate, test_badges) = set_up(); + let (app, krate, test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); badges.insert( String::from("is-it-maintained-open-issues"), test_badges.isitmaintained_open_issues_attributes ); - Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.isitmaintained_open_issues]); + Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); + assert_eq!(krate.badges(&conn).unwrap(), vec![test_badges.isitmaintained_open_issues]); } #[test] fn update_add_codecov() { // Add a codecov badge - let (req, krate, test_badges) = set_up(); + let (app, krate, test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); badges.insert( String::from("codecov"), test_badges.codecov_attributes ); - Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.codecov]); + Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); + assert_eq!(krate.badges(&conn).unwrap(), vec![test_badges.codecov]); } #[test] fn update_add_coveralls() { // Add a coveralls badge - let (req, krate, test_badges) = set_up(); + let (app, krate, test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); badges.insert( String::from("coveralls"), test_badges.coveralls_attributes ); - Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![test_badges.coveralls]); + Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); + assert_eq!(krate.badges(&conn).unwrap(), vec![test_badges.coveralls]); } #[test] @@ -431,7 +435,8 @@ fn gitlab_required_keys() { #[test] fn isitmaintained_issue_resolution_required_keys() { // Add a isitmaintained_issue_resolution badge missing a required field - let (req, krate, mut test_badges) = set_up(); + let (app, krate, mut test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); @@ -442,16 +447,17 @@ fn isitmaintained_issue_resolution_required_keys() { test_badges.isitmaintained_issue_resolution_attributes ); - let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); assert_eq!(invalid_badges.len(), 1); - assert!(invalid_badges.contains(&String::from("isitmaintained_issue_resolution"))); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); + assert!(invalid_badges.contains(&"isitmaintained_issue_resolution")); + assert_eq!(krate.badges(&conn).unwrap(), vec![]); } #[test] fn isitmaintained_open_issues_required_keys() { // Add a isitmaintained_open_issues badge missing a required field - let (req, krate, mut test_badges) = set_up(); + let (app, krate, mut test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); @@ -462,16 +468,17 @@ fn isitmaintained_open_issues_required_keys() { test_badges.isitmaintained_open_issues_attributes ); - let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); assert_eq!(invalid_badges.len(), 1); - assert!(invalid_badges.contains(&String::from("isitmaintained_open_issues"))); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); + assert!(invalid_badges.contains(&"isitmaintained_open_issues")); + assert_eq!(krate.badges(&conn).unwrap(), vec![]); } #[test] fn codecov_required_keys() { // Add a codecov badge missing a required field - let (req, krate, mut test_badges) = set_up(); + let (app, krate, mut test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); @@ -482,16 +489,17 @@ fn codecov_required_keys() { test_badges.codecov_attributes ); - let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); assert_eq!(invalid_badges.len(), 1); - assert!(invalid_badges.contains(&String::from("codecov"))); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); + assert!(invalid_badges.contains(&"codecov")); + assert_eq!(krate.badges(&conn).unwrap(), vec![]); } #[test] fn coveralls_required_keys() { // Add a coveralls badge missing a required field - let (req, krate, mut test_badges) = set_up(); + let (app, krate, mut test_badges) = set_up(); + let conn = app.diesel_database.get().unwrap(); let mut badges = HashMap::new(); @@ -502,10 +510,10 @@ fn coveralls_required_keys() { test_badges.coveralls_attributes ); - let invalid_badges = Badge::update_crate_old(req.tx().unwrap(), &krate, badges).unwrap(); + let invalid_badges = Badge::update_crate(&conn, &krate, Some(&badges)).unwrap(); assert_eq!(invalid_badges.len(), 1); - assert!(invalid_badges.contains(&String::from("coveralls"))); - assert_eq!(krate.badges(req.tx().unwrap()).unwrap(), vec![]); + assert!(invalid_badges.contains(&"coveralls")); + assert_eq!(krate.badges(&conn).unwrap(), vec![]); } #[test]