From 159bf11b48b61c7c0e0228623b1c7e8939460585 Mon Sep 17 00:00:00 2001
From: Erik Hanson <erik@erikhanson.dev>
Date: Fri, 5 Jul 2024 15:57:24 -0700
Subject: [PATCH] pkp/pkp-lib#10127 WIP add DepositOrcidSubmissionTest

---
 .../jobs/orcid/DepositOrcidSubmissionTest.php | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 tests/jobs/orcid/DepositOrcidSubmissionTest.php

diff --git a/tests/jobs/orcid/DepositOrcidSubmissionTest.php b/tests/jobs/orcid/DepositOrcidSubmissionTest.php
new file mode 100644
index 00000000000..9594bd3b7a5
--- /dev/null
+++ b/tests/jobs/orcid/DepositOrcidSubmissionTest.php
@@ -0,0 +1,50 @@
+<?php
+
+/**
+ * @file tests/jobs/orcid/DepositOrcidSubmissionTest.php
+ *
+ * Copyright (c) 2014-2024 Simon Fraser University
+ * Copyright (c) 2000-2024 John Willinsky
+ * Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
+ *
+ * @brief Tests for the deposit ORCID submission job.
+ */
+
+namespace APP\tests\jobs\orcid;
+
+use PKP\jobs\orcid\DepositOrcidSubmission;
+use PKP\tests\PKPTestCase;
+
+/**
+ * @runTestsInSeparateProcesses
+ *
+ * @see https://docs.phpunit.de/en/9.6/annotations.html#runtestsinseparateprocesses
+ */
+class DepositOrcidSubmissionTest extends PKPTestCase
+{
+    /**
+     * base64_encoded serialization from OJS 3.5.0
+     */
+    protected string $serializedJobData = 'O:37:"PKP\jobs\orcid\DepositOrcidSubmission":6:{s:45:" PKP\jobs\orcid\DepositOrcidSubmission author";O:17:"APP\author\Author":7:{s:5:"_data";a:17:{s:2:"id";i:26;s:5:"email";s:27:"vkarbasizaed@mailinator.com";s:15:"includeInBrowse";b:1;s:13:"publicationId";i:18;s:3:"seq";i:0;s:11:"userGroupId";i:14;s:7:"country";s:2:"IR";s:5:"orcid";s:37:"https://orcid.org/0000-0002-1825-0097";s:20:"orcidAccessExpiresOn";s:19:"2044-07-05 16:21:04";s:16:"orcidAccessScope";s:18:"/activities/update";s:16:"orcidAccessToken";s:20:"xxxx-xxxx-xxxxx-xxxx";s:15:"orcidIsVerified";b:1;s:17:"orcidRefreshToken";s:19:"xxxx-xxxx-xxxx-xxxx";s:11:"affiliation";a:1:{s:2:"en";s:20:"University of Tehran";}s:10:"familyName";a:1:{s:2:"en";s:11:"Karbasizaed";}s:9:"givenName";a:1:{s:2:"en";s:7:"Vajiheh";}s:6:"locale";s:2:"en";}s:20:"_hasLoadableAdapters";b:0;s:27:"_metadataExtractionAdapters";a:0:{}s:25:"_extractionAdaptersLoaded";b:0;s:26:"_metadataInjectionAdapters";a:0:{}s:24:"_injectionAdaptersLoaded";b:0;s:13:"_localesTable";a:9:{s:11:"be@cyrillic";s:2:"be";s:2:"bs";s:7:"bs_Latn";s:5:"fr_FR";s:2:"fr";s:2:"nb";s:5:"nb_NO";s:11:"sr@cyrillic";s:7:"sr_Cyrl";s:8:"sr@latin";s:7:"sr_Latn";s:11:"uz@cyrillic";s:2:"uz";s:8:"uz@latin";s:7:"uz_Latn";s:5:"zh_CN";s:7:"zh_Hans";}}s:46:" PKP\jobs\orcid\DepositOrcidSubmission context";O:19:"APP\journal\Journal":7:{s:5:"_data";a:79:{s:2:"id";i:1;s:7:"urlPath";s:15:"publicknowledge";s:7:"enabled";b:1;s:3:"seq";i:1;s:13:"primaryLocale";s:2:"en";s:14:"currentIssueId";i:1;s:7:"acronym";a:1:{s:2:"en";s:6:"JPKJPK";}s:16:"authorGuidelines";a:2:{s:2:"en";s:1209:"<p>Authors are invited to make a submission to this journal. All submissions will be assessed by an editor to determine whether they meet the aims and scope of this journal. Those considered to be a good fit will be sent for peer review before determining whether they will be accepted or rejected.</p><p>Before making a submission, authors are responsible for obtaining permission to publish any material included with the submission, such as photos, documents and datasets. All authors identified on the submission must consent to be identified as an author. Where appropriate, research should be approved by an appropriate ethics committee in accordance with the legal requirements of the study's country.</p><p>An editor may desk reject a submission if it does not meet minimum standards of quality. Before submitting, please ensure that the study design and research argument are structured and articulated properly. The title should be concise and the abstract should be able to stand on its own. This will increase the likelihood of reviewers agreeing to review the paper. When you're satisfied that your submission meets this standard, please follow the checklist below to prepare your submission.</p>";s:5:"fr_CA";s:1516:"<p>Les auteur.e.s sont invité.e.s à soumettre un article à cette revue. Toutes les soumissions seront évaluées par un.e rédacteur.trice afin de déterminer si elles correspondent aux objectifs et au champ d'application de cette revue. Ceux considérés comme étant appropriés seront envoyés à des pairs pour examen avant de décider s'ils seront acceptés ou rejetés.</p><p>Avant de soumettre leur article, les auteur.e.s sont responsables d'obtenir l'autorisation de publier tout matériel inclus dans la soumission, tels que des photos, des documents et des ensembles de données. Tous les auteur.e.s identifié.e.s dans la soumission doivent consentir à être identifié.e.s comme auteur.e.s. Lorsque cela est approprié, la recherche doit être approuvée par un comité d'éthique approprié conformément aux exigences légales du pays de l'étude.</p><p>Un.e rédacteur.trice peut rejeter une soumission sans examen approfondi s'il ne répond pas aux normes minimales de qualité. Avant de soumettre votre article, veuillez vous assurer que la conception de l'étude et l'argument de recherche sont structurés et articulés correctement. Le titre doit être concis et le résumé doit pouvoir être compris indépendamment du reste du texte. Cela augmentera la probabilité que les évaluateur.trice.s acceptent d'examiner l'article. Lorsque vous êtes confiant.e que votre article répond à ces exigences, vous pouvez suivre la liste de contrôle ci-dessous pour préparer votre soumission.</p>";}s:17:"authorInformation";a:2:{s:2:"en";s:586:"Interested in submitting to this journal? We recommend that you review the <a href="http://localhost/index.php/publicknowledge/about">About the Journal</a> page for the journal's section policies, as well as the <a href="http://localhost/index.php/publicknowledge/about/submissions#authorGuidelines">Author Guidelines</a>. Authors need to <a href="http://localhost/index.php/publicknowledge/user/register">register</a> with the journal prior to submitting or, if already registered, can simply <a href="http://localhost/index.php/index/login">log in</a> and begin the five-step process.";s:5:"fr_CA";s:715:"Intéressé-e à soumettre à cette revue ? Nous vous recommandons de consulter les politiques de rubrique de la revue à la page <a href="http://localhost/index.php/publicknowledge/about">À propos de la revue</a> ainsi que les <a href="http://localhost/index.php/publicknowledge/about/submissions#authorGuidelines">Directives aux auteurs</a>. Les auteurs-es doivent <a href="http://localhost/index.php/publicknowledge/user/register">s'inscrire</a> auprès de la revue avant de présenter une soumission, ou s'ils et elles sont déjà inscrits-es, simplement <a href="http://localhost/index.php/publicknowledge/login">ouvrir une session</a> et accéder au tableau de bord pour commencer les 5 étapes du processus.";}s:19:"beginSubmissionHelp";a:2:{s:2:"en";s:611:"<p>Thank you for submitting to the Journal of Public Knowledge. You will be asked to upload files, identify co-authors, and provide information such as the title and abstract.<p><p>Please read our <a href="http://localhost/index.php/publicknowledge/about/submissions" target="_blank">Submission Guidelines</a> if you have not done so already. When filling out the forms, provide as many details as possible in order to help our editors evaluate your work.</p><p>Once you begin, you can save your submission and come back to it later. You will be able to review and correct any information before you submit.</p>";s:5:"fr_CA";s:762:"<p>Merci de votre soumission à la revue Journal of Public Knowledge. Il vous sera demandé de téléverser des fichiers, identifier des co-auteur.trice.s et fournir des informations comme le titre et le résumé.<p><p>Si vous ne l'avez pas encore fait, merci de consulter nos <a href="http://localhost/index.php/publicknowledge/about/submissions" target="_blank">Recommandations pour la soumission</a>. Lorsque vous remplissez les formulaires, merci de fournir autant de détails que possible pour aider nos éditeur.trice.s à évaluer votre travail. </p><p>Une fois que vous avez commencé, vous pouvez enregistrer votre soumission et y revenir plus tard. Vous pourrez alors réviser et modifier toutes les informations voulues avant de soumettre le tout.</p>";}s:12:"contactEmail";s:20:"rvaca@mailinator.com";s:11:"contactName";s:11:"Ramiro Vaca";s:16:"contributorsHelp";a:2:{s:2:"en";s:504:"<p>Add details for all of the contributors to this submission. Contributors added here will be sent an email confirmation of the submission, as well as a copy of all editorial decisions recorded against this submission.</p><p>If a contributor can not be contacted by email, because they must remain anonymous or do not have an email account, please do not enter a fake email address. You can add information about this contributor in a message to the editor at a later step in the submission process.</p>";s:5:"fr_CA";s:613:"<p>Ajouter des informations relatives à tous les contributeurs.trices à cette soumission. Les contributeurs.trices ajouté.e.s ici se verront envoyer un courriel de confirmation de la soumission ainsi qu'une copie de toutes les décisions éditoriales enregistrées pour cette soumission.</p><p>Si un.e contributeur.trice ne peut être contacté.e par courriel parce qu'il ou elle doit demeurer anonyme ou n'a pas de compte de messagerie, veuillez ne pas entrer de courriel fictif. Vous pouvez ajouter des informations sur ce ou cette contributeur.trice à une étape ultérieure du processus de soumission.</p>";}s:7:"country";s:2:"IS";s:17:"defaultReviewMode";i:2;s:11:"description";a:2:{s:2:"en";s:123:"<p>The Journal of Public Knowledge is a peer-reviewed quarterly publication on the subject of public access to science.</p>";s:5:"fr_CA";s:146:"<p>Le Journal de Public Knowledge est une publication trimestrielle évaluée par les pairs sur le thème de l'accès du public à la science.</p>";}s:11:"detailsHelp";a:2:{s:2:"en";s:92:"<p>Please provide the following details to help us manage your submission in our system.</p>";s:5:"fr_CA";s:117:"<p>Veuillez fournir les informations suivantes afin de nous aider à gérer votre soumission dans notre système.</p>";}s:31:"copySubmissionAckPrimaryContact";b:0;s:24:"copySubmissionAckAddress";s:0:"";s:14:"emailSignature";s:141:"<br><br>—<br><p>This is an automated message from <a href="http://localhost/index.php/publicknowledge">Journal of Public Knowledge</a>.</p>";s:10:"enableDois";b:1;s:13:"doiSuffixType";s:7:"default";s:18:"registrationAgency";s:0:"";s:18:"disableSubmissions";b:0;s:19:"editorialStatsEmail";b:1;s:17:"forTheEditorsHelp";a:2:{s:2:"en";s:278:"<p>Please provide the following details in order to help our editorial team manage your submission.</p><p>When entering metadata, provide entries that you think would be most helpful to the person managing your submission. This information can be changed before publication.</p>";s:5:"fr_CA";s:329:"<p>S'il vous plaît, fournissez les détails suivants afin d'aider l'équipe éditoriale à gérer votre soumission.</p><p>Dans vos métadonnées, assurez vous de fournir des informations que vous pensez pouvoir être utile à la personne qui gérera votre soumission. Cette information peut être changée avant publication.</p>";}s:12:"itemsPerPage";i:25;s:8:"keywords";s:7:"request";s:20:"librarianInformation";a:2:{s:2:"en";s:361:"We encourage research librarians to list this journal among their library's electronic journal holdings. As well, it may be worth noting that this journal's open source publishing system is suitable for libraries to host for their faculty members to use with journals they are involved in editing (see <a href="https://pkp.sfu.ca/ojs">Open Journal Systems</a>).";s:5:"fr_CA";s:434:"Nous incitons les bibliothécaires à lister cette revue dans leur fonds de revues numériques. Aussi, il peut être pertinent de mentionner que ce système de publication en libre accès est conçu pour être hébergé par les bibliothèques de recherche pour que les membres de leurs facultés l'utilisent avec les revues dans lesquelles elles ou ils sont impliqués (voir <a href="https://pkp.sfu.ca/ojs">Open Journal Systems</a>).";}s:4:"name";a:2:{s:2:"en";s:27:"Journal of Public Knowledge";s:5:"fr_CA";s:36:"Journal de la connaissance du public";}s:16:"notifyAllAuthors";b:1;s:12:"numPageLinks";i:10;s:19:"numWeeksPerResponse";i:4;s:17:"numWeeksPerReview";i:4;s:25:"numReviewersPerSubmission";i:0;s:16:"openAccessPolicy";a:2:{s:2:"en";s:176:"This journal provides immediate open access to its content on the principle that making research freely available to the public supports a greater global exchange of knowledge.";s:5:"fr_CA";s:217:"Cette revue fournit le libre accès immédiat à son contenu se basant sur le principe que rendre la recherche disponible au public gratuitement facilite un plus grand échange du savoir, à l'échelle de la planète.";}s:9:"orcidCity";s:9:"Vancouver";s:13:"orcidClientId";s:18:"APP-xxxxxxxxxxxxxx";s:17:"orcidClientSecret";s:19:"xxxxxxxxxxxxxxxxxxx";s:12:"orcidEnabled";b:1;s:13:"orcidLogLevel";s:5:"ERROR";s:35:"orcidSendMailToAuthorsOnPublication";b:1;s:16:"privacyStatement";a:2:{s:2:"en";s:206:"<p>The names and email addresses entered in this journal site will be used exclusively for the stated purposes of this journal and will not be made available for any other purpose or to any other party.</p>";s:5:"fr_CA";s:193:"<p>Les noms et courriels saisis dans le site de cette revue seront utilisés exclusivement aux fins indiquées par cette revue et ne serviront à aucune autre fin, ni à toute autre partie.</p>";}s:17:"readerInformation";a:2:{s:2:"en";s:654:"We encourage readers to sign up for the publishing notification service for this journal. Use the <a href="http://localhost/index.php/publicknowledge/user/register">Register</a> link at the top of the home page for the journal. This registration will result in the reader receiving the Table of Contents by email for each new issue of the journal. This list also allows the journal to claim a certain level of support or readership. See the journal's <a href="http://localhost/index.php/publicknowledge/about/submissions#privacyStatement">Privacy Statement</a>, which assures readers that their name and email address will not be used for other purposes.";s:5:"fr_CA";s:716:"Nous invitons les lecteurs-trices à s'inscrire pour recevoir les avis de publication de cette revue. Utiliser le lien <a href="http://localhost/index.php/publicknowledge/user/register">S'inscrire</a> en haut de la page d'accueil de la revue. Cette inscription permettra au,à la lecteur-trice de recevoir par courriel le sommaire de chaque nouveau numéro de la revue. Cette liste permet aussi à la revue de revendiquer un certain niveau de soutien ou de lectorat. Voir la <a href="http://localhost/index.php/publicknowledge/about/submissions#privacyStatement">Déclaration de confidentialité</a> de la revue qui certifie aux lecteurs-trices que leur nom et leur courriel ne seront pas utilisés à d'autres fins.";}s:10:"reviewHelp";a:2:{s:2:"en";s:368:"<p>Review the information you have entered before you complete your submission. You can change any of the details displayed here by clicking the edit button at the top of each section.</p><p>Once you complete your submission, a member of our editorial team will be assigned to review it. Please ensure the details you have entered here are as accurate as possible.</p>";s:5:"fr_CA";s:402:"<p>Révisez l'information que vous avez fourni avant de finaliser votre soumission. Vous pouvez modifier chaque détails affichés en cliquant sur le bouton d'édition en haut de chaque section.</p><p>Une fois votre soumission transmise, un membre de l'équipe éditoriale lui sera assigné afin de l'évaluer. S'il vous plaît, assurez vous que les détails fournis sont le plus exactes possibles.</p>";}s:25:"submissionAcknowledgement";s:10:"allAuthors";s:19:"submissionChecklist";a:2:{s:2:"en";s:591:"<p>All submissions must meet the following requirements.</p><ul><li>This submission meets the requirements outlined in the <a href="http://localhost/index.php/publicknowledge/about/submissions">Author Guidelines</a>.</li><li>This submission has not been previously published, nor is it before another journal for consideration.</li><li>All references have been checked for accuracy and completeness.</li><li>All tables and figures have been numbered and labeled.</li><li>Permission has been obtained to publish all photos, datasets and other material provided with this submission.</li></ul>";s:5:"fr_CA";s:643:"<p>Toutes les soumissions doivent répondre aux exigences suivantes : </p><ul><li>Cette soumission répond aux exigences définies dans les <a href="http://localhost/index.php/publicknowledge/about/submissions">directives aux auteur.e.s</a>.</li><li>Cette soumission n'a ni été publiée précédemment, ni été soumise à une autre revue.</li><li>Toutes les références ont été vérifiées et sont exactes.</li><li>Tous les tableaux et figures sont numérotés et définis.</li><li>L'autorisation de publier toutes les photos, tous les ensembles de données et tout autre matériel fourni avec cette soumission a été obtenue.</li></ul>";}s:20:"submitWithCategories";b:0;s:31:"supportedAddedSubmissionLocales";a:2:{i:0;s:2:"en";i:1;s:5:"fr_CA";}s:32:"supportedDefaultSubmissionLocale";s:2:"en";s:20:"supportedFormLocales";a:2:{i:0;s:2:"en";i:1;s:5:"fr_CA";}s:16:"supportedLocales";a:2:{i:0;s:2:"en";i:1;s:5:"fr_CA";}s:26:"supportedSubmissionLocales";a:2:{i:0;s:2:"en";i:1;s:5:"fr_CA";}s:34:"supportedSubmissionMetadataLocales";a:2:{i:0;s:2:"en";i:1;s:5:"fr_CA";}s:15:"themePluginPath";s:7:"default";s:15:"uploadFilesHelp";a:2:{s:2:"en";s:249:"<p>Provide any files our editorial team may need to evaluate your submission. In addition to the main work, you may wish to submit data sets, conflict of interest statements, or other supplementary files if these will be helpful for our editors.</p>";s:5:"fr_CA";s:317:"<p> Fournir tous les fichiers dont notre équipe éditoriale pourrait avoir besoin pour évaluer votre soumission. En plus du fichier principal, vous pouvez soumettre des ensembles de données, une déclaration relative au conflit d'intérêt ou tout autre fichier potentiellement utile pour nos éditeur.trice.s.</p>";}s:19:"enableGeoUsageStats";s:8:"disabled";s:27:"enableInstitutionUsageStats";b:0;s:16:"isSushiApiPublic";b:1;s:14:"clockssLicense";a:2:{s:2:"en";s:271:"This journal utilizes the CLOCKSS system to create a distributed archiving system among participating libraries and permits those libraries to create permanent archives of the journal for purposes of preservation and restoration. <a href="https://clockss.org">More...</a>";s:5:"fr_CA";s:315:"Cette revue utilise le système CLOCKSS pour créer un système d'archivage distribué parmi les bibliothèques participantes et permet à ces bibliothèques de créer des archives permanentes de la revue à des fins de conservation et de reconstitution. <a href="https://clockss.org">En apprendre davantage... </a>";}s:18:"copyrightYearBasis";s:5:"issue";s:15:"enabledDoiTypes";a:1:{i:0;s:11:"publication";}s:15:"doiCreationTime";s:20:"copyEditCreationTime";s:9:"enableOai";b:1;s:13:"lockssLicense";a:2:{s:2:"en";s:273:"This journal utilizes the LOCKSS system to create a distributed archiving system among participating libraries and permits those libraries to create permanent archives of the journal for purposes of preservation and restoration. <a href="https://www.lockss.org">More...</a>";s:5:"fr_CA";s:314:"Cette revue utilise le système LOCKSS pour créer un système de distribution des archives parmi les bibliothèques participantes et afin de permettre à ces bibliothèques de créer des archives permanentes pour fins de préservation et de restauration. <a href="https://lockss.org">En apprendre davantage...</a>";}s:13:"membershipFee";d:0;s:14:"publicationFee";d:0;s:18:"purchaseArticleFee";d:0;s:13:"doiVersioning";b:0;s:13:"customHeaders";a:1:{s:2:"en";s:41:"<meta name="pkp" content="Test metatag.">";}s:17:"searchDescription";a:1:{s:2:"en";s:116:"The Journal of Public Knowledge is a peer-reviewed quarterly publication on the subject of public access to science.";}s:12:"abbreviation";a:1:{s:2:"en";s:25:"publicknowledgeJ Pub Know";}s:10:"onlineIssn";s:9:"0378-5955";s:9:"printIssn";s:9:"0378-5955";s:20:"publisherInstitution";s:24:"Public Knowledge Project";s:14:"mailingAddress";s:49:"123 456th Street
Burnaby, British Columbia
Canada";s:12:"supportEmail";s:20:"rvaca@mailinator.com";s:11:"supportName";s:11:"Ramiro Vaca";s:12:"orcidApiType";s:13:"memberSandbox";}s:20:"_hasLoadableAdapters";b:0;s:27:"_metadataExtractionAdapters";a:0:{}s:25:"_extractionAdaptersLoaded";b:0;s:26:"_metadataInjectionAdapters";a:0:{}s:24:"_injectionAdaptersLoaded";b:0;s:13:"_localesTable";a:9:{s:11:"be@cyrillic";s:2:"be";s:2:"bs";s:7:"bs_Latn";s:5:"fr_FR";s:2:"fr";s:2:"nb";s:5:"nb_NO";s:11:"sr@cyrillic";s:7:"sr_Cyrl";s:8:"sr@latin";s:7:"sr_Latn";s:11:"uz@cyrillic";s:2:"uz";s:8:"uz@latin";s:7:"uz_Latn";s:5:"zh_CN";s:7:"zh_Hans";}}s:48:" PKP\jobs\orcid\DepositOrcidSubmission orcidWork";a:10:{s:5:"title";a:2:{s:5:"title";a:1:{s:5:"value";s:137:"Antimicrobial, heavy metal resistance and plasmid profile of coliforms isolated from nosocomial infections in a hospital in Isfahan, Iran";}s:8:"subtitle";a:1:{s:5:"value";s:0:"";}}s:13:"journal-title";a:1:{s:5:"value";s:27:"Journal of Public Knowledge";}s:17:"short-description";s:1156:"The antimicrobial, heavy metal resistance patterns and plasmid profiles of Coliforms (Enterobacteriacea) isolated from nosocomial infections and healthy human faeces were compared. Fifteen of the 25 isolates from nosocomial infections were identified as Escherichia coli, and remaining as Kelebsiella pneumoniae. Seventy two percent of the strains isolated from nosocomial infections possess multiple resistance to antibiotics compared to 45% of strains from healthy human faeces. The difference between minimal inhibitory concentration (MIC) values of strains from clinical cases and from faeces for four heavy metals (Hg, Cu, Pb, Cd) was not significant. However most strains isolated from hospital were more tolerant to heavy metal than those from healthy persons. There was no consistent relationship between plasmid profile group and antimicrobial resistance pattern, although a conjugative plasmid (>56.4 kb) encoding resistance to heavy metals and antibiotics was recovered from eight of the strains isolated from nosocomial infections. The results indicate multidrug-resistance coliforms as a potential cause of nosocomial infection in this region.";s:12:"external-ids";a:1:{s:11:"external-id";a:2:{i:0;a:3:{s:16:"external-id-type";s:3:"uri";s:17:"external-id-value";s:60:"http://ojsdev.test/index.php/publicknowledge/article/view/17";s:24:"external-id-relationship";s:4:"self";}i:1;a:3:{s:16:"external-id-type";s:4:"issn";s:17:"external-id-value";s:9:"0378-5955";s:24:"external-id-relationship";s:7:"part-of";}}}s:16:"publication-date";a:3:{s:4:"year";a:1:{s:5:"value";s:4:"2024";}s:5:"month";a:1:{s:5:"value";s:2:"07";}s:3:"day";a:1:{s:5:"value";s:2:"03";}}s:3:"url";s:60:"http://ojsdev.test/index.php/publicknowledge/article/view/17";s:13:"language-code";s:2:"en";s:12:"contributors";a:1:{s:11:"contributor";a:1:{i:0;a:3:{s:11:"credit-name";s:19:"Vajiheh Karbasizaed";s:22:"contributor-attributes";a:2:{s:20:"contributor-sequence";s:5:"first";s:16:"contributor-role";s:6:"AUTHOR";}s:17:"contributor-orcid";a:3:{s:3:"uri";s:37:"https://orcid.org/0000-0002-1825-0097";s:4:"path";s:19:"0000-0002-1825-0097";s:4:"host";s:9:"orcid.org";}}}}s:8:"citation";a:2:{s:13:"citation-type";s:6:"bibtex";s:14:"citation-value";s:1491:"@article{Antimicrobial, heavy metal resistance and plasmid profile of coliforms isolated from nosocomial infections in a hospital in Isfahan, Iran_2024, volume={1}, url={http://ojsdev.test/index.php/publicknowledge/article/view/17}, abstractNote={The antimicrobial, heavy metal resistance patterns and plasmid profiles of Coliforms (Enterobacteriacea) isolated from nosocomial infections and healthy human faeces were compared. Fifteen of the 25 isolates from nosocomial infections were identified as Escherichia coli, and remaining as Kelebsiella pneumoniae. Seventy two percent of the strains isolated from nosocomial infections possess multiple resistance to antibiotics compared to 45% of strains from healthy human faeces. The difference between minimal inhibitory concentration (MIC) values of strains from clinical cases and from faeces for four heavy metals (Hg, Cu, Pb, Cd) was not significant. However most strains isolated from hospital were more tolerant to heavy metal than those from healthy persons. There was no consistent relationship between plasmid profile group and antimicrobial resistance pattern, although a conjugative plasmid (&amp;gt;56.4 kb) encoding resistance to heavy metals and antibiotics was recovered from eight of the strains isolated from nosocomial infections. The results indicate multidrug-resistance coliforms as a potential cause of nosocomial infection in this region.}, number={2}, journal={Journal of Public Knowledge}, year={2024}, month={Jul.} }";}s:4:"type";s:15:"journal-article";}s:50:" PKP\jobs\orcid\DepositOrcidSubmission authorOrcid";s:19:"0000-0002-1825-0097";s:10:"connection";s:8:"database";s:5:"queue";s:5:"queue";}';
+
+    /**
+     * Test job is a proper instance
+     */
+    public function testUnserializeGetProperJobInstance(): void
+    {
+        $this->assertInstanceOf(
+            DepositOrcidSubmission::class,
+            unserialize(base64_decode($this->serializedJobData)),
+        );
+    }
+
+    public function testRunSerializedJob(): void
+    {
+        $this->mockGuzzleClient();
+
+        /** @var DepositOrcidSubmission $depositOrcidSubmissionJob */
+        $depositOrcidSubmissionJob = unserialize(base64_decode($this->serializedJobData));
+
+        $this->assertNull($depositOrcidSubmissionJob->handle());
+    }
+}