Merge pull request #69 from pelotech/cleanup-on-fail

Pass --cleanup-on-fail when so instructed

.drone.yml

@@ -17,11 +17,16 @@ steps:
     image: golang:1.13
     commands:
       - go build -o build/drone-helm cmd/drone-helm/main.go
-  - name: publish
+  - name: publish_linux_amd64
     image: plugins/docker
-    auto_tag: true
     settings:
+      auto_tag: true
+      username:
+        from_secret: docker_username
+      password:
+        from_secret: docker_password
+      repo:
+        from_secret: plugin_repo
       dockerfile: Dockerfile
-      registry: '192.168.0.17:5000'
+    when:
-      repo: 192.168.0.17:5000/drone-helm3
+      event: [ tag, push ]
-      insecure: true

.github/CODEOWNERS

@@ -0,0 +1 @@
+*       @erincall @grinnellian @kav @josmo

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,17 @@
+---
+name: Bug report
+about: Unexpected or broken behavior
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**What I tried to do:**
+<!-- e.g. run a helm installation -->
+
+**What happened:**
+<!-- describe the faulty behavior -->
+
+**More info:**
+<!-- contents of .drone.yml, etc. -->

.github/ISSUE_TEMPLATE/documentation.md

@@ -0,0 +1,11 @@
+---
+name: Documentation
+about: Docs you'd like to see, or questions about existing docs
+title: ''
+labels: documentation
+assignees: ''
+
+---
+
+**What needs explanation:**
+<!-- e.g. "what happens when ____", "how do I ___", etc. -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,14 @@
+---
+name: Feature request
+about: Suggest a new feature
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**The problem I'm trying to solve:**
+<!-- describe what you'd like to be able to accomplish -->
+
+**How I imagine it working:**
+<!-- e.g. configuration that could go in .drone.yml -->

.github/pull_request_template.md

@@ -0,0 +1,10 @@
+**Please replace this line with "fixes #ISSUE_NUMBER" (or "relates to #ISSUE_NUMBER", if it is not a complete fix)**
+
+Pre-merge checklist:
+
+* [ ] Code changes have tests
+* [ ] Any config changes are documented:
+    * If the change touches _required_ config, there's a corresponding update to `README.md`
+    * There's a corresponding update to `docs/parameter_reference.md`
+    * There's a pull request to update [the parameter reference in drone-plugin-index](https://github.com/drone/drone-plugin-index/blob/master/content/pelotech/drone-helm3/index.md)
+* [ ] Any large changes have been verified by running a Drone job

.gitignore

@@ -5,6 +5,8 @@
 *.so
 *.dylib
 
+.idea
+
 # Test binary, built with `go test -c`
 *.test
 
@@ -13,3 +15,5 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+.env
+.secrets

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [workwithus@pelo.tech](mailto:workwithus@pelo.tech). All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

Dockerfile

@@ -1,8 +1,8 @@
-FROM alpine/helm
+FROM alpine/helm:3.0.2
 MAINTAINER Erin Call <erin@liffft.com>
 
 COPY build/drone-helm /bin/drone-helm
-COPY kubeconfig /root/.kube/config.tpl
+COPY assets/kubeconfig.tpl /root/.kube/config.tpl
 
 LABEL description="Helm 3 plugin for Drone 3"
 LABEL base="alpine/helm"

LICENSE

@@ -1,674 +1,202 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+                                 Apache License
- Everyone is permitted to copy and distribute verbatim copies
+                           Version 2.0, January 2004
- of this license document, but changing it is not allowed.
+                        http://www.apache.org/licenses/
-
+
-                            Preamble
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
+
-  The GNU General Public License is a free, copyleft license for
+   1. Definitions.
-software and other kinds of works.
+
-
+      "License" shall mean the terms and conditions for use, reproduction,
-  The licenses for most software and other practical works are designed
+      and distribution as defined by Sections 1 through 9 of this document.
-to take away your freedom to share and change the works.  By contrast,
+
-the GNU General Public License is intended to guarantee your freedom to
+      "Licensor" shall mean the copyright owner or entity authorized by
-share and change all versions of a program--to make sure it remains free
+      the copyright owner that is granting the License.
-software for all its users.  We, the Free Software Foundation, use the
+
-GNU General Public License for most of our software; it applies also to
+      "Legal Entity" shall mean the union of the acting entity and all
-any other work released this way by its authors.  You can apply it to
+      other entities that control, are controlled by, or are under common
-your programs, too.
+      control with that entity. For the purposes of this definition,
-
+      "control" means (i) the power, direct or indirect, to cause the
-  When we speak of free software, we are referring to freedom, not
+      direction or management of such entity, whether by contract or
-price.  Our General Public Licenses are designed to make sure that you
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-have the freedom to distribute copies of free software (and charge for
+      outstanding shares, or (iii) beneficial ownership of such entity.
-them if you wish), that you receive source code or can get it if you
+
-want it, that you can change the software or use pieces of it in new
+      "You" (or "Your") shall mean an individual or Legal Entity
-free programs, and that you know you can do these things.
+      exercising permissions granted by this License.
-
+
-  To protect your rights, we need to prevent others from denying you
+      "Source" form shall mean the preferred form for making modifications,
-these rights or asking you to surrender the rights.  Therefore, you have
+      including but not limited to software source code, documentation
-certain responsibilities if you distribute copies of the software, or if
+      source, and configuration files.
-you modify it: responsibilities to respect the freedom of others.
+
-
+      "Object" form shall mean any form resulting from mechanical
-  For example, if you distribute copies of such a program, whether
+      transformation or translation of a Source form, including but
-gratis or for a fee, you must pass on to the recipients the same
+      not limited to compiled object code, generated documentation,
-freedoms that you received.  You must make sure that they, too, receive
+      and conversions to other media types.
-or can get the source code.  And you must show them these terms so they
+
-know their rights.
+      "Work" shall mean the work of authorship, whether in Source or
-
+      Object form, made available under the License, as indicated by a
-  Developers that use the GNU GPL protect your rights with two steps:
+      copyright notice that is included in or attached to the work
-(1) assert copyright on the software, and (2) offer you this License
+      (an example is provided in the Appendix below).
-giving you legal permission to copy, distribute and/or modify it.
+
-
+      "Derivative Works" shall mean any work, whether in Source or Object
-  For the developers' and authors' protection, the GPL clearly explains
+      form, that is based on (or derived from) the Work and for which the
-that there is no warranty for this free software.  For both users' and
+      editorial revisions, annotations, elaborations, or other modifications
-authors' sake, the GPL requires that modified versions be marked as
+      represent, as a whole, an original work of authorship. For the purposes
-changed, so that their problems will not be attributed erroneously to
+      of this License, Derivative Works shall not include works that remain
-authors of previous versions.
+      separable from, or merely link (or bind by name) to the interfaces of,
-
+      the Work and Derivative Works thereof.
-  Some devices are designed to deny users access to install or run
+
-modified versions of the software inside them, although the manufacturer
+      "Contribution" shall mean any work of authorship, including
-can do so.  This is fundamentally incompatible with the aim of
+      the original version of the Work and any modifications or additions
-protecting users' freedom to change the software.  The systematic
+      to that Work or Derivative Works thereof, that is intentionally
-pattern of such abuse occurs in the area of products for individuals to
+      submitted to Licensor for inclusion in the Work by the copyright owner
-use, which is precisely where it is most unacceptable.  Therefore, we
+      or by an individual or Legal Entity authorized to submit on behalf of
-have designed this version of the GPL to prohibit the practice for those
+      the copyright owner. For the purposes of this definition, "submitted"
-products.  If such problems arise substantially in other domains, we
+      means any form of electronic, verbal, or written communication sent
-stand ready to extend this provision to those domains in future versions
+      to the Licensor or its representatives, including but not limited to
-of the GPL, as needed to protect the freedom of users.
+      communication on electronic mailing lists, source code control systems,
-
+      and issue tracking systems that are managed by, or on behalf of, the
-  Finally, every program is threatened constantly by software patents.
+      Licensor for the purpose of discussing and improving the Work, but
-States should not allow patents to restrict development and use of
+      excluding communication that is conspicuously marked or otherwise
-software on general-purpose computers, but in those that do, we wish to
+      designated in writing by the copyright owner as "Not a Contribution."
-avoid the special danger that patents applied to a free program could
+
-make it effectively proprietary.  To prevent this, the GPL assures that
+      "Contributor" shall mean Licensor and any individual or Legal Entity
-patents cannot be used to render the program non-free.
+      on behalf of whom a Contribution has been received by Licensor and
-
+      subsequently incorporated within the Work.
-  The precise terms and conditions for copying, distribution and
+
-modification follow.
+   2. Grant of Copyright License. Subject to the terms and conditions of
-
+      this License, each Contributor hereby grants to You a perpetual,
-                       TERMS AND CONDITIONS
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-
+      copyright license to reproduce, prepare Derivative Works of,
-  0. Definitions.
+      publicly display, publicly perform, sublicense, and distribute the
-
+      Work and such Derivative Works in Source or Object form.
-  "This License" refers to version 3 of the GNU General Public License.
+
-
+   3. Grant of Patent License. Subject to the terms and conditions of
-  "Copyright" also means copyright-like laws that apply to other kinds of
+      this License, each Contributor hereby grants to You a perpetual,
-works, such as semiconductor masks.
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-
+      (except as stated in this section) patent license to make, have made,
-  "The Program" refers to any copyrightable work licensed under this
+      use, offer to sell, sell, import, and otherwise transfer the Work,
-License.  Each licensee is addressed as "you".  "Licensees" and
+      where such license applies only to those patent claims licensable
-"recipients" may be individuals or organizations.
+      by such Contributor that are necessarily infringed by their
-
+      Contribution(s) alone or by combination of their Contribution(s)
-  To "modify" a work means to copy from or adapt all or part of the work
+      with the Work to which such Contribution(s) was submitted. If You
-in a fashion requiring copyright permission, other than the making of an
+      institute patent litigation against any entity (including a
-exact copy.  The resulting work is called a "modified version" of the
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
-earlier work or a work "based on" the earlier work.
+      or a Contribution incorporated within the Work constitutes direct
-
+      or contributory patent infringement, then any patent licenses
-  A "covered work" means either the unmodified Program or a work based
+      granted to You under this License for that Work shall terminate
-on the Program.
+      as of the date such litigation is filed.
-
+
-  To "propagate" a work means to do anything with it that, without
+   4. Redistribution. You may reproduce and distribute copies of the
-permission, would make you directly or secondarily liable for
+      Work or Derivative Works thereof in any medium, with or without
-infringement under applicable copyright law, except executing it on a
+      modifications, and in Source or Object form, provided that You
-computer or modifying a private copy.  Propagation includes copying,
+      meet the following conditions:
-distribution (with or without modification), making available to the
+
-public, and in some countries other activities as well.
+      (a) You must give any other recipients of the Work or
-
+          Derivative Works a copy of this License; and
-  To "convey" a work means any kind of propagation that enables other
+
-parties to make or receive copies.  Mere interaction with a user through
+      (b) You must cause any modified files to carry prominent notices
-a computer network, with no transfer of a copy, is not conveying.
+          stating that You changed the files; and
-
+
-  An interactive user interface displays "Appropriate Legal Notices"
+      (c) You must retain, in the Source form of any Derivative Works
-to the extent that it includes a convenient and prominently visible
+          that You distribute, all copyright, patent, trademark, and
-feature that (1) displays an appropriate copyright notice, and (2)
+          attribution notices from the Source form of the Work,
-tells the user that there is no warranty for the work (except to the
+          excluding those notices that do not pertain to any part of
-extent that warranties are provided), that licensees may convey the
+          the Derivative Works; and
-work under this License, and how to view a copy of this License.  If
+
-the interface presents a list of user commands or options, such as a
+      (d) If the Work includes a "NOTICE" text file as part of its
-menu, a prominent item in the list meets this criterion.
+          distribution, then any Derivative Works that You distribute must
-
+          include a readable copy of the attribution notices contained
-  1. Source Code.
+          within such NOTICE file, excluding those notices that do not
-
+          pertain to any part of the Derivative Works, in at least one
-  The "source code" for a work means the preferred form of the work
+          of the following places: within a NOTICE text file distributed
-for making modifications to it.  "Object code" means any non-source
+          as part of the Derivative Works; within the Source form or
-form of a work.
+          documentation, if provided along with the Derivative Works; or,
-
+          within a display generated by the Derivative Works, if and
-  A "Standard Interface" means an interface that either is an official
+          wherever such third-party notices normally appear. The contents
-standard defined by a recognized standards body, or, in the case of
+          of the NOTICE file are for informational purposes only and
-interfaces specified for a particular programming language, one that
+          do not modify the License. You may add Your own attribution
-is widely used among developers working in that language.
+          notices within Derivative Works that You distribute, alongside
-
+          or as an addendum to the NOTICE text from the Work, provided
-  The "System Libraries" of an executable work include anything, other
+          that such additional attribution notices cannot be construed
-than the work as a whole, that (a) is included in the normal form of
+          as modifying the License.
-packaging a Major Component, but which is not part of that Major
+
-Component, and (b) serves only to enable use of the work with that
+      You may add Your own copyright statement to Your modifications and
-Major Component, or to implement a Standard Interface for which an
+      may provide additional or different license terms and conditions
-implementation is available to the public in source code form.  A
+      for use, reproduction, or distribution of Your modifications, or
-"Major Component", in this context, means a major essential component
+      for any such Derivative Works as a whole, provided Your use,
-(kernel, window system, and so on) of the specific operating system
+      reproduction, and distribution of the Work otherwise complies with
-(if any) on which the executable work runs, or a compiler used to
+      the conditions stated in this License.
-produce the work, or an object code interpreter used to run it.
+
-
+   5. Submission of Contributions. Unless You explicitly state otherwise,
-  The "Corresponding Source" for a work in object code form means all
+      any Contribution intentionally submitted for inclusion in the Work
-the source code needed to generate, install, and (for an executable
+      by You to the Licensor shall be under the terms and conditions of
-work) run the object code and to modify the work, including scripts to
+      this License, without any additional terms or conditions.
-control those activities.  However, it does not include the work's
+      Notwithstanding the above, nothing herein shall supersede or modify
-System Libraries, or general-purpose tools or generally available free
+      the terms of any separate license agreement you may have executed
-programs which are used unmodified in performing those activities but
+      with Licensor regarding such Contributions.
-which are not part of the work.  For example, Corresponding Source
+
-includes interface definition files associated with source files for
+   6. Trademarks. This License does not grant permission to use the trade
-the work, and the source code for shared libraries and dynamically
+      names, trademarks, service marks, or product names of the Licensor,
-linked subprograms that the work is specifically designed to require,
+      except as required for reasonable and customary use in describing the
-such as by intimate data communication or control flow between those
+      origin of the Work and reproducing the content of the NOTICE file.
-subprograms and other parts of the work.
+
-
+   7. Disclaimer of Warranty. Unless required by applicable law or
-  The Corresponding Source need not include anything that users
+      agreed to in writing, Licensor provides the Work (and each
-can regenerate automatically from other parts of the Corresponding
+      Contributor provides its Contributions) on an "AS IS" BASIS,
-Source.
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-
+      implied, including, without limitation, any warranties or conditions
-  The Corresponding Source for a work in source code form is that
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-same work.
+      PARTICULAR PURPOSE. You are solely responsible for determining the
-
+      appropriateness of using or redistributing the Work and assume any
-  2. Basic Permissions.
+      risks associated with Your exercise of permissions under this License.
-
+
-  All rights granted under this License are granted for the term of
+   8. Limitation of Liability. In no event and under no legal theory,
-copyright on the Program, and are irrevocable provided the stated
+      whether in tort (including negligence), contract, or otherwise,
-conditions are met.  This License explicitly affirms your unlimited
+      unless required by applicable law (such as deliberate and grossly
-permission to run the unmodified Program.  The output from running a
+      negligent acts) or agreed to in writing, shall any Contributor be
-covered work is covered by this License only if the output, given its
+      liable to You for damages, including any direct, indirect, special,
-content, constitutes a covered work.  This License acknowledges your
+      incidental, or consequential damages of any character arising as a
-rights of fair use or other equivalent, as provided by copyright law.
+      result of this License or out of the use or inability to use the
-
+      Work (including but not limited to damages for loss of goodwill,
-  You may make, run and propagate covered works that you do not
+      work stoppage, computer failure or malfunction, or any and all
-convey, without conditions so long as your license otherwise remains
+      other commercial damages or losses), even if such Contributor
-in force.  You may convey covered works to others for the sole purpose
+      has been advised of the possibility of such damages.
-of having them make modifications exclusively for you, or provide you
+
-with facilities for running those works, provided that you comply with
+   9. Accepting Warranty or Additional Liability. While redistributing
-the terms of this License in conveying all material for which you do
+      the Work or Derivative Works thereof, You may choose to offer,
-not control copyright.  Those thus making or running the covered works
+      and charge a fee for, acceptance of support, warranty, indemnity,
-for you must do so exclusively on your behalf, under your direction
+      or other liability obligations and/or rights consistent with this
-and control, on terms that prohibit them from making any copies of
+      License. However, in accepting such obligations, You may act only
-your copyrighted material outside their relationship with you.
+      on Your own behalf and on Your sole responsibility, not on behalf
-
+      of any other Contributor, and only if You agree to indemnify,
-  Conveying under any other circumstances is permitted solely under
+      defend, and hold each Contributor harmless for any liability
-the conditions stated below.  Sublicensing is not allowed; section 10
+      incurred by, or claims asserted against, such Contributor by reason
-makes it unnecessary.
+      of your accepting any such warranty or additional liability.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
 
    END OF TERMS AND CONDITIONS
 
-            How to Apply These Terms to Your New Programs
+   APPENDIX: How to apply the Apache License to your work.
 
-  If you develop a new program, and you want it to be of the greatest
+      To apply the Apache License to your work, attach the following
-possible use to the public, the best way to achieve this is to make it
+      boilerplate notice, with the fields enclosed by brackets "[]"
-free software which everyone can redistribute and change under these terms.
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
 
-  To do so, attach the following notices to the program.  It is safest
+   Copyright [yyyy] [name of copyright owner]
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
 
-    <one line to give the program's name and a brief idea of what it does.>
+   Licensed under the Apache License, Version 2.0 (the "License");
-    Copyright (C) <year>  <name of author>
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
 
-    This program is free software: you can redistribute it and/or modify
+       http://www.apache.org/licenses/LICENSE-2.0
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
 
-    This program is distributed in the hope that it will be useful,
+   Unless required by applicable law or agreed to in writing, software
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+   distributed under the License is distributed on an "AS IS" BASIS,
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    GNU General Public License for more details.
+   See the License for the specific language governing permissions and
-
+   limitations under the License.
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,15 +1,86 @@
 # Drone plugin for Helm 3
 
-TODO:
+[![Build Status](https://cloud.drone.io/api/badges/pelotech/drone-helm3/status.svg)](https://cloud.drone.io/pelotech/drone-helm3)
+[![Go Report](https://goreportcard.com/badge/github.com/pelotech/drone-helm3)](https://goreportcard.com/report/github.com/pelotech/drone-helm3)
+[![](https://images.microbadger.com/badges/image/pelotech/drone-helm3.svg)](https://microbadger.com/images/pelotech/drone-helm3 "Get your own image badge on microbadger.com")
 
-* [x] Make a `.drone.yml` that's sufficient for building an image
+This plugin provides an interface between [Drone](https://drone.io/) and [Helm 3](https://github.com/kubernetes/helm):
-* [x] Make a `Dockerfile` that's sufficient for launching the built image
+
-* [x] Make `cmd/drone-helm/main.go` actually invoke `helm`
+* Lint your charts
-* [x] Make `golint` part of the build process (and make it pass)
+* Deploy your service
-* [x] Implement debug output
+* Delete your service
-* [x] Flesh out `helm upgrade` until it's capable of working
+
-* [ ] Implement config settings for `upgrade`
+The plugin is inpsired by [drone-helm](https://github.com/ipedrazas/drone-helm), which fills the same role for Helm 2. It provides a comparable feature-set and the configuration settings are backwards-compatible.
-* [ ] Implement `helm lint`
+
-* [ ] Implement `helm delete`
+## Example configuration
-* [ ] EKS support
+
-* [ ] Change `.drone.yml` to use a real docker registry
+The examples below give a minimal and sufficient configuration for each use-case. For a full description of each command's settings, see [docs/parameter_reference.md](docs/parameter_reference.md).
+
+### Linting
+
+```yaml
+steps:
+  - name: lint
+    image: pelotech/drone-helm3
+    settings:
+      helm_command: lint
+      chart: ./
+```
+
+### Installation
+
+```yaml
+steps:
+  - name: deploy
+    image: pelotech/drone-helm3
+    settings:
+      helm_command: upgrade
+      chart: ./
+      release: my-project
+    environment:
+      API_SERVER: https://my.kubernetes.installation/clusters/a-1234
+      KUBERNETES_TOKEN:
+        from_secret: kubernetes_token
+```
+
+### Uninstallation
+
+```yaml
+steps:
+  - name: uninstall
+    image: pelotech/drone-helm3
+    settings:
+      helm_command: uninstall
+      release: my-project
+    environment:
+      API_SERVER: https://my.kubernetes.installation/clusters/a-1234
+      KUBERNETES_TOKEN:
+        from_secret: kubernetes_token
+```
+
+## Upgrading from drone-helm
+
+drone-helm3 is largely backwards-compatible with drone-helm. There are some known differences:
+
+* You'll need to migrate the deployments in the cluster [helm-v2-to-helm-v3](https://helm.sh/blog/migrate-from-helm-v2-to-helm-v3/).
+* EKS is not supported. See [#5](https://github.com/pelotech/drone-helm3/issues/5) for more information.
+* The `prefix` setting is no longer supported. If you were relying on the `prefix` setting with `secrets: [...]`, you'll need to switch to the `from_secret` syntax.
+* During uninstallations, the release history is purged by default. Use `keep_history: true` to return to the old behavior.
+* Several settings no longer have any effect. The plugin will produce warnings if any of these are present:
+    * `purge` -- this is the default behavior in Helm 3
+    * `recreate_pods`
+    * `tiller_ns`
+    * `upgrade`
+    * `canary_image`
+    * `client_only`
+    * `stable_repo_url`
+
+Since helm 3 does not require Tiller, we also recommend switching to a service account with less-expansive permissions.
+
+### [Contributing](docs/contributing.md)
+
+This repo is setup in a way that if you enable a personal drone server to build your fork it will
+ build and publish your image (makes it easier to test PRs and use the image till the contributions get merged)
+
+* Build local ```DRONE_REPO_OWNER=josmo DRONE_REPO_NAME=drone-ecs drone exec```
+* on your server (or cloud.drone.io) just make sure you have DOCKER_USERNAME, DOCKER_PASSWORD, and PLUGIN_REPO set as secrets

assets/kubeconfig.tpl

@@ -3,7 +3,7 @@ clusters:
 - cluster:
 {{- if eq .SkipTLSVerify true }}
     insecure-skip-tls-verify: true
-{{- else }}
+{{- else if .Certificate }}
     certificate-authority-data: {{ .Certificate }}
 {{- end}}
     server: {{ .APIServer }}
@@ -24,16 +24,4 @@ users:
   user:
 {{- if .Token }}
     token: {{ .Token }}
-{{- else if .EKSCluster }}
-    exec:
-      apiVersion: client.authentication.k8s.io/v1alpha1
-      command: aws-iam-authenticator
-      args:
-        - "token"
-        - "-i"
-        - "{{ .EKSCluster }}"
-    {{- if .EKSRoleARN }}
-        - "-r"
-        - "{{ .EKSRoleARN }}"
-    {{- end }}
 {{- end }}

cmd/drone-helm/main.go

@@ -2,22 +2,22 @@ package main
 
 import (
 	"fmt"
-	"github.com/kelseyhightower/envconfig"
 	"os"
 
+	_ "github.com/joho/godotenv/autoload"
 	"github.com/pelotech/drone-helm3/internal/helm"
 )
 
 func main() {
-	var c helm.Config
+	cfg, err := helm.NewConfig(os.Stdout, os.Stderr)
 
-	if err := envconfig.Process("plugin", &c); err != nil {
+	if err != nil {
 		fmt.Fprintf(os.Stderr, "%s\n", err.Error())
 		return
 	}
 
 	// Make the plan
-	plan, err := helm.NewPlan(c)
+	plan, err := helm.NewPlan(*cfg)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "%w\n", err)
 		os.Exit(1)
@@ -28,7 +28,7 @@ func main() {
 
 	// Expect the plan to go off the rails
 	if err != nil {
-		fmt.Fprintf(os.Stderr, err.Error())
+		fmt.Fprintf(os.Stderr, "%s\n", err.Error())
 		// Throw away the plan
 		os.Exit(1)
 	}

docs/contributing.md

@@ -0,0 +1,48 @@
+# Contributing to drone-helm3
+
+We're glad you're interested in contributing! Here are some guidelines that will help make sure everyone has a good experience:
+
+## Submitting a patch
+
+Before you start working on a change, please make sure there's an associated issue. It doesn't need to be thoroughly scrutinized and dissected, but it needs to exist.
+
+Please put the relevant issue number in the first line of your commit messages, e.g. `vorpalize the frabjulator [#42]`. Branch names do not need issue numbers, but feel free to include them if you like.
+
+We encourage you to follow [the guidelines in Pro Git](https://git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-Project#_commit_guidelines) when making commits. In short:
+
+* Commit early and commit often.
+* Make the first line of the commit message concise--no more than 50 characters or so.
+* Make the rest of the commit message verbose--information about _why_ you did what you did is particularly helpful.
+
+Once you're satisfied with your work, send us a pull request. If you'd like, you can send the pull request _before_ you're satisfied with your work; just be sure to mark the PR a draft or put `[WIP]` in the title.
+
+## How to run the tests
+
+We use `go test`, `go vet`, and `golint`:
+
+```
+go test ./cmd/... ./internal/...
+go vet ./cmd/... ./internal/...
+golint -set_exit_status ./cmd/... ./internal/...
+```
+
+If you have [the Drone cli tool](https://docs.drone.io/cli/install/) installed, you can also use `drone exec --include test --include lint`.
+
+## Testing the plugin end-to-end
+
+Although we aim to make the internal tests as thorough as possible, they can't test drone-helm3's integration with drone and helm themselves. However, you can test a change manually by building an image and running it with a fixture repository.
+
+You will need:
+
+* Access to a docker image registry. This document assumes you'll use [Docker Hub](https://hub.docker.com).
+* [The Drone cli tool](https://docs.drone.io/cli/install/).
+* A fixture repository--a directory with a `.drone.yml` and a helm chart. If you don't have one handy, try adding a `.drone.yml` to a chart from [Helm's "stable" repository](https://github.com/helm/charts/tree/master/stable/).
+* Access to a kubernetes cluster (unless `lint` or `dry_run` is sufficient for your purposes).
+
+Once you have what you need, you can publish and consume an image with your changes:
+
+1. [Create a repository on Docker Hub](https://hub.docker.com/repository/create). This document assumes you've called it drone-helm3-testing.
+1. Create a `.secrets` file with your docker credentials (see [example.secrets](./example.secrets) for an example). While you can use your Docker Hub password, it's better to [generate an access token](https://hub.docker.com/settings/security) and use that instead.
+1. Use Drone to build and publish an image with your changes: `drone exec --secret-file ./secrets --event push`
+1. In the `.drone.yml` of your fixture repository, set the `image` for each relevant stanza to `your_dockerhub_username/drone-helm3-testing`
+1. Use `drone exec` in the fixture repo to verify your changes.

docs/example.secrets

@@ -0,0 +1,3 @@
+DOCKER_PASSWORD=your_access_token
+DOCKER_USERNAME=your_dockerhub_username
+PLUGIN_REPO=your_dockerhub_username/drone-helm3-testing

docs/parameter_reference.md

@@ -0,0 +1,94 @@
+# Parameter reference
+
+## Global
+| Param name          | Type            | Purpose |
+|---------------------|-----------------|---------|
+| helm_command        | string          | Indicates the operation to perform. Recommended, but not required. Valid options are `upgrade`, `uninstall`, `lint`, and `help`. |
+| update_dependencies | boolean         | Calls `helm dependency update` before running the main command.|
+| helm_repos          | list\<string\>  | Calls `helm repo add $repo` before running the main command. Each string should be formatted as `repo_name=https://repo.url/`. |
+| namespace           | string          | Kubernetes namespace to use for this operation. |
+| debug               | boolean         | Generate debug output within drone-helm3 and pass `--debug` to all helm commands. Use with care, since the debug output may include secrets. |
+
+## Linting
+
+Linting is only triggered when the `helm_command` setting is "lint".
+
+| Param name    | Type           | Required | Purpose |
+|---------------|----------------|----------|---------|
+| chart         | string         | yes      | The chart to be linted. Must be a local path. |
+| values        | list\<string\> |          | Chart values to use as the `--set` argument to `helm lint`. |
+| string_values | list\<string\> |          | Chart values to use as the `--set-string` argument to `helm lint`. |
+| values_files  | list\<string\> |          | Values to use as `--values` arguments to `helm lint`. |
+| lint_strictly | boolean        |          | Pass `--strict` to `helm lint`, to turn warnings into errors. |
+
+## Installation
+
+Installations are triggered when the `helm_command` setting is "upgrade." They can also be triggered when the build was triggered by a `push`, `tag`, `deployment`, `pull_request`, `promote`, or `rollback` Drone event.
+
+| Param name             | Type           | Required | Purpose |
+|------------------------|----------------|----------|---------|
+| chart                  | string         | yes      | The chart to use for this installation. |
+| release                | string         | yes      | The release name for helm to use. |
+| api_server             | string         | yes      | API endpoint for the Kubernetes cluster. |
+| kubernetes_token       | string         | yes      | Token for authenticating to Kubernetes. |
+| service_account        | string         |          | Service account for authenticating to Kubernetes. Default is `helm`. |
+| kubernetes_certificate | string         |          | Base64 encoded TLS certificate used by the Kubernetes cluster's certificate authority. |
+| chart_version          | string         |          | Specific chart version to install. |
+| dry_run                | boolean        |          | Pass `--dry-run` to `helm upgrade`. |
+| wait                   | boolean        |          | Wait until kubernetes resources are in a ready state before marking the installation successful. |
+| timeout                | duration       |          | Timeout for any *individual* Kubernetes operation. The installation's full runtime may exceed this duration. |
+| force                  | boolean        |          | Pass `--force` to `helm upgrade`. |
+| atomic_upgrade         | boolean        |          | Pass `--atomic` to `helm upgrade`. |
+| cleanup_failed_upgrade | boolean        |          | Pass `--cleanup-on-fail` to `helm upgrade`. |
+| values                 | list\<string\> |          | Chart values to use as the `--set` argument to `helm upgrade`. |
+| string_values          | list\<string\> |          | Chart values to use as the `--set-string` argument to `helm upgrade`. |
+| values_files           | list\<string\> |          | Values to use as `--values` arguments to `helm upgrade`. |
+| reuse_values           | boolean        |          | Reuse the values from a previous release. |
+| skip_tls_verify        | boolean        |          | Connect to the Kubernetes cluster without checking for a valid TLS certificate. Not recommended in production. |
+
+## Uninstallation
+
+Uninstallations are triggered when the `helm_command` setting is "uninstall" or "delete." They can also be triggered when the build was triggered by a `delete` Drone event.
+
+| Param name             | Type     | Required | Purpose |
+|------------------------|----------|----------|---------|
+| release                | string   | yes      | The release name for helm to use. |
+| api_server             | string   | yes      | API endpoint for the Kubernetes cluster. |
+| kubernetes_token       | string   | yes      | Token for authenticating to Kubernetes. |
+| service_account        | string   |          | Service account for authenticating to Kubernetes. Default is `helm`. |
+| kubernetes_certificate | string   |          | Base64 encoded TLS certificate used by the Kubernetes cluster's certificate authority. |
+| keep_history           | boolean  |          | Pass `--keep-history` to `helm uninstall`, to retain the release history. |
+| dry_run                | boolean  |          | Pass `--dry-run` to `helm uninstall`. |
+| timeout                | duration |          | Timeout for any *individual* Kubernetes operation. The uninstallation's full runtime may exceed this duration. |
+| skip_tls_verify        | boolean  |          | Connect to the Kubernetes cluster without checking for a valid TLS certificate. Not recommended in production. |
+| chart                  | string   |          | Required when the global `update_dependencies` parameter is true. No effect otherwise. |
+
+### Where to put settings
+
+Any setting can go in either the `settings` or `environment` section. If a setting exists in _both_ sections, the version in `environment` will override the version in `settings`.
+
+We recommend putting all drone-helm3 configuration in the `settings` block and limiting the `environment` block to variables that are used when building your charts.
+
+### Formatting non-string values
+
+* Booleans can be yaml's `true` and `false` literals or the strings `"true"` and `"false"`.
+* Durations are strings formatted with the syntax accepted by [golang's ParseDuration function](https://golang.org/pkg/time/#ParseDuration) (e.g. 5m30s)
+  * For backward-compatibility with drone-helm, a duration can also be an integer, in which case it will be interpreted to mean seconds.
+* List\<string\>s can be a yaml sequence or a comma-separated string.
+
+All of the following are equivalent:
+
+```yaml
+values: "foo=1,bar=2"
+values: ["foo=1", "bar=2"]
+values:
+  - foo=1
+  - bar=2
+```
+
+Note that **list members must not contain commas**. Both of the following are equivalent:
+
+```yaml
+values_files: [ "./over_9,000.yml" ]
+values_files: [ "./over_9", "000.yml" ]
+```

go.mod

@@ -4,8 +4,10 @@ go 1.13
 
 require (
 	github.com/golang/mock v1.3.1
+	github.com/joho/godotenv v1.3.0 // indirect
 	github.com/kelseyhightower/envconfig v1.4.0
 	github.com/stretchr/testify v1.4.0
 	golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f // indirect
 	golang.org/x/tools v0.0.0-20191209225234-22774f7dae43 // indirect
+	gopkg.in/yaml.v2 v2.2.2
 )

go.sum

@@ -2,6 +2,8 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang/mock v1.3.1 h1:qGJ6qTW+x6xX/my+8YUVl4WNpX9B7+/l2tRsHGZ7f2s=
 github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
+github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
 github.com/kelseyhightower/envconfig v1.4.0 h1:Im6hONhd3pLkfDFsbRgu68RDNkGF1r3dvMUtDTo2cv8=
 github.com/kelseyhightower/envconfig v1.4.0/go.mod h1:cccZRl6mQpaq41TPp5QxidR+Sa3axMbJDNb//FQX6Gg=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

internal/helm/config.go

@@ -2,62 +2,95 @@ package helm
 
 import (
 	"fmt"
+	"github.com/kelseyhightower/envconfig"
+	"io"
+	"os"
+	"regexp"
 	"strings"
 )
 
+var (
+	justNumbers    = regexp.MustCompile(`^\d+$`)
+	deprecatedVars = []string{"PURGE", "RECREATE_PODS", "TILLER_NS", "UPGRADE", "CANARY_IMAGE", "CLIENT_ONLY", "STABLE_REPO_URL"}
+)
+
 // The Config struct captures the `settings` and `environment` blocks in the application's drone
 // config. Configuration in drone's `settings` block arrives as uppercase env vars matching the
-// config key, prefixed with `PLUGIN_`. Config from the `environment` block is *not* prefixed; any
+// config key, prefixed with `PLUGIN_`. Config from the `environment` block is uppercased, but does
-// keys that are likely to be in that block (i.e. things that use `from_secret` need an explicit
+// not have the `PLUGIN_` prefix.
-// `envconfig:` tag so that envconfig will look for a non-prefixed env var.
 type Config struct {
 	// Configuration for drone-helm itself
-	Command            helmCommand `envconfig:"HELM_COMMAND"`      // Helm command to run
+	Command            string   `envconfig:"HELM_COMMAND"`           // Helm command to run
 	DroneEvent         string   `envconfig:"DRONE_BUILD_EVENT"`      // Drone event that invoked this plugin.
-	UpdateDependencies bool        `split_words:"true"`            // call `helm dependency update` before the main command
+	UpdateDependencies bool     `split_words:"true"`                 // Call `helm dependency update` before the main command
-	Repos              []string    `envconfig:"HELM_REPOS"`        // call `helm repo add` before the main command
+	AddRepos           []string `envconfig:"HELM_REPOS"`             // Call `helm repo add` before the main command
-	Prefix             string      ``                              // Prefix to use when looking up secret env vars
+	Debug              bool     ``                                   // Generate debug output and pass --debug to all helm commands
+	Values             string   ``                                   // Argument to pass to --set in applicable helm commands
+	StringValues       string   `split_words:"true"`                 // Argument to pass to --set-string in applicable helm commands
+	ValuesFiles        []string `split_words:"true"`                 // Arguments to pass to --values in applicable helm commands
+	Namespace          string   ``                                   // Kubernetes namespace for all helm commands
+	KubeToken          string   `envconfig:"KUBERNETES_TOKEN"`       // Kubernetes authentication token to put in .kube/config
+	SkipTLSVerify      bool     `envconfig:"SKIP_TLS_VERIFY"`        // Put insecure-skip-tls-verify in .kube/config
+	Certificate        string   `envconfig:"KUBERNETES_CERTIFICATE"` // The Kubernetes cluster CA's self-signed certificate (must be base64-encoded)
+	APIServer          string   `envconfig:"API_SERVER"`             // The Kubernetes cluster's API endpoint
+	ServiceAccount     string   `split_words:"true"`                 // Account to use for connecting to the Kubernetes cluster
+	ChartVersion       string   `split_words:"true"`                 // Specific chart version to use in `helm upgrade`
+	DryRun             bool     `split_words:"true"`                 // Pass --dry-run to applicable helm commands
+	Wait               bool     ``                                   // Pass --wait to applicable helm commands
+	ReuseValues        bool     `split_words:"true"`                 // Pass --reuse-values to `helm upgrade`
+	KeepHistory        bool     `split_words:"true"`                 // Pass --keep-history to `helm uninstall`
+	Timeout            string   ``                                   // Argument to pass to --timeout in applicable helm commands
+	Chart              string   ``                                   // Chart argument to use in applicable helm commands
+	Release            string   ``                                   // Release argument to use in applicable helm commands
+	Force              bool     ``                                   // Pass --force to applicable helm commands
+	AtomicUpgrade      bool     `split_words:"true"`                 // Pass --atomic to `helm upgrade`
+	CleanupOnFail      bool     `envconfig:"CLEANUP_FAILED_UPGRADE"` // Pass --cleanup-on-fail to `helm upgrade`
+	LintStrictly       bool     `split_words:"true"`                 // Pass --strict to `helm lint`
 
-	// Global helm config
+	Stdout io.Writer `ignored:"true"`
-	Debug          bool     ``                                                // global helm flag (also applies to drone-helm itself)
+	Stderr io.Writer `ignored:"true"`
-	KubeConfig     string   `split_words:"true" default:"/root/.kube/config"` // path to the kube config file
-	Values         string   ``
-	StringValues   string   `split_words:"true"`
-	ValuesFiles    []string `split_words:"true"`
-	Namespace      string   ``
-	KubeToken      string   `envconfig:"KUBERNETES_TOKEN"`
-	SkipTLSVerify  bool     `envconfig:"SKIP_TLS_VERIFY"`
-	Certificate    string   `envconfig:"KUBERNETES_CERTIFICATE"`
-	APIServer      string   `envconfig:"API_SERVER"`
-	ServiceAccount string   `envconfig:"SERVICE_ACCOUNT"` // Can't just use split_words; need envconfig to find the non-prefixed form
-
-	// Config specifically for `helm upgrade`
-	ChartVersion string `split_words:"true"` //
-	DryRun       bool   `split_words:"true"` // also available for `delete`
-	Wait         bool   ``                   //
-	ReuseValues  bool   `split_words:"true"` //
-	Timeout      string ``                   //
-	Chart        string ``                   // Also available for `lint`, in which case it must be a path to a chart directory
-	Release      string ``
-	Force        bool   `` //
 }
 
-type helmCommand string
+// NewConfig creates a Config and reads environment variables into it, accounting for several possible formats.
-
+func NewConfig(stdout, stderr io.Writer) (*Config, error) {
-// helmCommand.Decode checks the given value against the list of known commands and generates a helpful error if the command is unknown.
+	cfg := Config{
-func (cmd *helmCommand) Decode(value string) error {
+		Stdout: stdout,
-	known := []string{"upgrade", "delete", "lint", "help"}
+		Stderr: stderr,
-	for _, c := range known {
-		if value == c {
-			*cmd = helmCommand(value)
-			return nil
 	}
+	if err := envconfig.Process("plugin", &cfg); err != nil {
+		return nil, err
 	}
 
-	if value == "" {
+	if err := envconfig.Process("", &cfg); err != nil {
-		return nil
+		return nil, err
+	}
+
+	if justNumbers.MatchString(cfg.Timeout) {
+		cfg.Timeout = fmt.Sprintf("%ss", cfg.Timeout)
+	}
+
+	if cfg.Debug && cfg.Stderr != nil {
+		cfg.logDebug()
+	}
+
+	cfg.deprecationWarn()
+
+	return &cfg, nil
+}
+
+func (cfg Config) logDebug() {
+	if cfg.KubeToken != "" {
+		cfg.KubeToken = "(redacted)"
+	}
+	fmt.Fprintf(cfg.Stderr, "Generated config: %+v\n", cfg)
+}
+
+func (cfg *Config) deprecationWarn() {
+	for _, varname := range deprecatedVars {
+		_, barePresent := os.LookupEnv(varname)
+		_, prefixedPresent := os.LookupEnv("PLUGIN_" + varname)
+		if barePresent || prefixedPresent {
+			fmt.Fprintf(cfg.Stderr, "Warning: ignoring deprecated '%s' setting\n", strings.ToLower(varname))
+		}
 	}
-	known[len(known)-1] = fmt.Sprintf("or %s", known[len(known)-1])
-	return fmt.Errorf("unknown command '%s'. If specified, command must be %s",
-		value, strings.Join(known, ", "))
 }

internal/helm/config_test.go

@@ -1,28 +1,162 @@
 package helm
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/suite"
+	"os"
+	"strings"
 	"testing"
 )
 
 type ConfigTestSuite struct {
 	suite.Suite
+	// These tests need to mutate the environment, so the suite.setenv and .unsetenv functions store the original contents of the
+	// relevant variable in this map. Its use of *string is so they can distinguish between "not set" and "set to empty string"
+	envBackup map[string]*string
 }
 
 func TestConfigTestSuite(t *testing.T) {
 	suite.Run(t, new(ConfigTestSuite))
 }
 
-func (suite *ConfigTestSuite) TestHelmCommandDecodeSuccess() {
+func (suite *ConfigTestSuite) TestNewConfigWithPluginPrefix() {
-	cmd := helmCommand("")
+	suite.unsetenv("HELM_COMMAND")
-	err := cmd.Decode("upgrade")
+	suite.unsetenv("UPDATE_DEPENDENCIES")
-	suite.Require().Nil(err)
+	suite.unsetenv("DEBUG")
 
-	suite.EqualValues(cmd, "upgrade")
+	suite.setenv("PLUGIN_HELM_COMMAND", "execute order 66")
+	suite.setenv("PLUGIN_UPDATE_DEPENDENCIES", "true")
+	suite.setenv("PLUGIN_DEBUG", "true")
+
+	cfg, err := NewConfig(&strings.Builder{}, &strings.Builder{})
+	suite.Require().NoError(err)
+
+	suite.Equal("execute order 66", cfg.Command)
+	suite.True(cfg.UpdateDependencies)
+	suite.True(cfg.Debug)
 }
 
-func (suite *ConfigTestSuite) TestHelmCommandDecodeFailure() {
+func (suite *ConfigTestSuite) TestNewConfigWithNoPrefix() {
-	cmd := helmCommand("")
+	suite.unsetenv("PLUGIN_HELM_COMMAND")
-	err := cmd.Decode("execute order 66")
+	suite.unsetenv("PLUGIN_UPDATE_DEPENDENCIES")
-	suite.EqualError(err, "unknown command 'execute order 66'. If specified, command must be upgrade, delete, lint, or help")
+	suite.unsetenv("PLUGIN_DEBUG")
+
+	suite.setenv("HELM_COMMAND", "execute order 66")
+	suite.setenv("UPDATE_DEPENDENCIES", "true")
+	suite.setenv("DEBUG", "true")
+
+	cfg, err := NewConfig(&strings.Builder{}, &strings.Builder{})
+	suite.Require().NoError(err)
+
+	suite.Equal("execute order 66", cfg.Command)
+	suite.True(cfg.UpdateDependencies)
+	suite.True(cfg.Debug)
+}
+
+func (suite *ConfigTestSuite) TestNewConfigWithConflictingVariables() {
+	suite.setenv("PLUGIN_HELM_COMMAND", "execute order 66")
+	suite.setenv("HELM_COMMAND", "defend the jedi") // values from the `environment` block override those from `settings`
+
+	cfg, err := NewConfig(&strings.Builder{}, &strings.Builder{})
+	suite.Require().NoError(err)
+
+	suite.Equal("defend the jedi", cfg.Command)
+}
+
+func (suite *ConfigTestSuite) TestNewConfigInfersNumbersAreSeconds() {
+	suite.setenv("PLUGIN_TIMEOUT", "42")
+	cfg, err := NewConfig(&strings.Builder{}, &strings.Builder{})
+	suite.Require().NoError(err)
+	suite.Equal("42s", cfg.Timeout)
+}
+
+func (suite *ConfigTestSuite) TestNewConfigSetsWriters() {
+	stdout := &strings.Builder{}
+	stderr := &strings.Builder{}
+	cfg, err := NewConfig(stdout, stderr)
+	suite.Require().NoError(err)
+
+	suite.Equal(stdout, cfg.Stdout)
+	suite.Equal(stderr, cfg.Stderr)
+}
+
+func (suite *ConfigTestSuite) TestDeprecatedSettingWarnings() {
+	for _, varname := range deprecatedVars {
+		suite.setenv(varname, "deprecoat") // environment-block entries should cause warnings
+	}
+
+	suite.unsetenv("PURGE")
+	suite.setenv("PLUGIN_PURGE", "true") // settings-block entries should cause warnings
+	suite.setenv("UPGRADE", "")          // entries should cause warnings even when set to empty string
+
+	stderr := &strings.Builder{}
+	_, err := NewConfig(&strings.Builder{}, stderr)
+	suite.NoError(err)
+
+	for _, varname := range deprecatedVars {
+		suite.Contains(stderr.String(), fmt.Sprintf("Warning: ignoring deprecated '%s' setting\n", strings.ToLower(varname)))
+	}
+}
+
+func (suite *ConfigTestSuite) TestLogDebug() {
+	suite.setenv("DEBUG", "true")
+	suite.setenv("HELM_COMMAND", "upgrade")
+
+	stderr := strings.Builder{}
+	stdout := strings.Builder{}
+	_, err := NewConfig(&stdout, &stderr)
+	suite.Require().NoError(err)
+
+	suite.Equal("", stdout.String())
+
+	suite.Regexp(`^Generated config: \{Command:upgrade.*\}`, stderr.String())
+}
+
+func (suite *ConfigTestSuite) TestLogDebugCensorsKubeToken() {
+	stderr := &strings.Builder{}
+	kubeToken := "I'm shy! Don't put me in your build logs!"
+	cfg := Config{
+		Debug:     true,
+		KubeToken: kubeToken,
+		Stderr:    stderr,
+	}
+
+	cfg.logDebug()
+
+	suite.Contains(stderr.String(), "KubeToken:(redacted)")
+	suite.Equal(kubeToken, cfg.KubeToken) // The actual config value should be left unchanged
+}
+
+func (suite *ConfigTestSuite) setenv(key, val string) {
+	orig, ok := os.LookupEnv(key)
+	if ok {
+		suite.envBackup[key] = &orig
+	} else {
+		suite.envBackup[key] = nil
+	}
+	os.Setenv(key, val)
+}
+
+func (suite *ConfigTestSuite) unsetenv(key string) {
+	orig, ok := os.LookupEnv(key)
+	if ok {
+		suite.envBackup[key] = &orig
+	} else {
+		suite.envBackup[key] = nil
+	}
+	os.Unsetenv(key)
+}
+
+func (suite *ConfigTestSuite) BeforeTest(_, _ string) {
+	suite.envBackup = make(map[string]*string)
+}
+
+func (suite *ConfigTestSuite) AfterTest(_, _ string) {
+	for key, val := range suite.envBackup {
+		if val == nil {
+			os.Unsetenv(key)
+		} else {
+			os.Setenv(key, *val)
+		}
+	}
 }

internal/helm/plan.go

@@ -6,7 +6,10 @@ import (
 	"os"
 )
 
-const kubeConfigTemplate = "/root/.kube/config.tpl"
+const (
+	kubeConfigTemplate = "/root/.kube/config.tpl"
+	kubeConfigFile     = "/root/.kube/config"
+)
 
 // A Step is one step in the plan.
 type Step interface {
@@ -27,13 +30,9 @@ func NewPlan(cfg Config) (*Plan, error) {
 		cfg: cfg,
 		runCfg: run.Config{
 			Debug:     cfg.Debug,
-			KubeConfig:   cfg.KubeConfig,
-			Values:       cfg.Values,
-			StringValues: cfg.StringValues,
-			ValuesFiles:  cfg.ValuesFiles,
 			Namespace: cfg.Namespace,
-			Stdout:       os.Stdout,
+			Stdout:    cfg.Stdout,
-			Stderr:       os.Stderr,
+			Stderr:    cfg.Stderr,
 		},
 	}
 
@@ -59,18 +58,20 @@ func determineSteps(cfg Config) *func(Config) []Step {
 	switch cfg.Command {
 	case "upgrade":
 		return &upgrade
-	case "delete":
+	case "uninstall", "delete":
-		panic("not implemented")
+		return &uninstall
 	case "lint":
-		panic("not implemented")
+		return &lint
 	case "help":
 		return &help
 	default:
 		switch cfg.DroneEvent {
 		case "push", "tag", "deployment", "pull_request", "promote", "rollback":
 			return &upgrade
+		case "delete":
+			return &uninstall
 		default:
-			panic("not implemented")
+			return &help
 		}
 	}
 }
@@ -79,11 +80,11 @@ func determineSteps(cfg Config) *func(Config) []Step {
 func (p *Plan) Execute() error {
 	for i, step := range p.steps {
 		if p.cfg.Debug {
-			fmt.Fprintf(os.Stderr, "calling %T.Execute (step %d)\n", step, i)
+			fmt.Fprintf(p.cfg.Stderr, "calling %T.Execute (step %d)\n", step, i)
 		}
 
 		if err := step.Execute(p.runCfg); err != nil {
-			return fmt.Errorf("in execution step %d: %w", i, err)
+			return fmt.Errorf("while executing %T step: %w", step, err)
 		}
 	}
 
@@ -91,31 +92,96 @@ func (p *Plan) Execute() error {
 }
 
 var upgrade = func(cfg Config) []Step {
-	steps := make([]Step, 0)
+	steps := initKube(cfg)
-
+	steps = append(steps, addRepos(cfg)...)
-	steps = append(steps, &run.InitKube{
+	if cfg.UpdateDependencies {
-		SkipTLSVerify:  cfg.SkipTLSVerify,
+		steps = append(steps, depUpdate(cfg)...)
-		Certificate:    cfg.Certificate,
+	}
-		APIServer:      cfg.APIServer,
-		ServiceAccount: cfg.ServiceAccount,
-		Token:          cfg.KubeToken,
-		TemplateFile:   kubeConfigTemplate,
-	})
-
 	steps = append(steps, &run.Upgrade{
 		Chart:         cfg.Chart,
 		Release:       cfg.Release,
 		ChartVersion:  cfg.ChartVersion,
+		DryRun:        cfg.DryRun,
 		Wait:          cfg.Wait,
+		Values:        cfg.Values,
+		StringValues:  cfg.StringValues,
+		ValuesFiles:   cfg.ValuesFiles,
 		ReuseValues:   cfg.ReuseValues,
 		Timeout:       cfg.Timeout,
 		Force:         cfg.Force,
+		Atomic:        cfg.AtomicUpgrade,
+		CleanupOnFail: cfg.CleanupOnFail,
+	})
+
+	return steps
+}
+
+var uninstall = func(cfg Config) []Step {
+	steps := initKube(cfg)
+	if cfg.UpdateDependencies {
+		steps = append(steps, depUpdate(cfg)...)
+	}
+	steps = append(steps, &run.Uninstall{
+		Release:     cfg.Release,
+		DryRun:      cfg.DryRun,
+		KeepHistory: cfg.KeepHistory,
+	})
+
+	return steps
+}
+
+var lint = func(cfg Config) []Step {
+	steps := addRepos(cfg)
+	if cfg.UpdateDependencies {
+		steps = append(steps, depUpdate(cfg)...)
+	}
+	steps = append(steps, &run.Lint{
+		Chart:        cfg.Chart,
+		Values:       cfg.Values,
+		StringValues: cfg.StringValues,
+		ValuesFiles:  cfg.ValuesFiles,
+		Strict:       cfg.LintStrictly,
 	})
 
 	return steps
 }
 
 var help = func(cfg Config) []Step {
-	help := &run.Help{}
+	help := &run.Help{
+		HelmCommand: cfg.Command,
+	}
 	return []Step{help}
 }
+
+func initKube(cfg Config) []Step {
+	return []Step{
+		&run.InitKube{
+			SkipTLSVerify:  cfg.SkipTLSVerify,
+			Certificate:    cfg.Certificate,
+			APIServer:      cfg.APIServer,
+			ServiceAccount: cfg.ServiceAccount,
+			Token:          cfg.KubeToken,
+			TemplateFile:   kubeConfigTemplate,
+			ConfigFile:     kubeConfigFile,
+		},
+	}
+}
+
+func addRepos(cfg Config) []Step {
+	steps := make([]Step, 0)
+	for _, repo := range cfg.AddRepos {
+		steps = append(steps, &run.AddRepo{
+			Repo: repo,
+		})
+	}
+
+	return steps
+}
+
+func depUpdate(cfg Config) []Step {
+	return []Step{
+		&run.DepUpdate{
+			Chart: cfg.Chart,
+		},
+	}
+}

internal/helm/plan_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/suite"
-	"os"
+	"strings"
 	"testing"
 
 	"github.com/pelotech/drone-helm3/internal/run"
@@ -20,6 +20,7 @@ func TestPlanTestSuite(t *testing.T) {
 
 func (suite *PlanTestSuite) TestNewPlan() {
 	ctrl := gomock.NewController(suite.T())
+	defer ctrl.Finish()
 	stepOne := NewMockStep(ctrl)
 	stepTwo := NewMockStep(ctrl)
 
@@ -29,25 +30,21 @@ func (suite *PlanTestSuite) TestNewPlan() {
 	}
 	defer func() { help = origHelp }()
 
+	stdout := strings.Builder{}
+	stderr := strings.Builder{}
 	cfg := Config{
 		Command:   "help",
 		Debug:     false,
-		KubeConfig:   "/branch/.sfere/profig",
-		Values:       "steadfastness,forthrightness",
-		StringValues: "tensile_strength,flexibility",
-		ValuesFiles:  []string{"/root/price_inventory.yml"},
 		Namespace: "outer",
+		Stdout:    &stdout,
+		Stderr:    &stderr,
 	}
 
 	runCfg := run.Config{
 		Debug:     false,
-		KubeConfig:   "/branch/.sfere/profig",
-		Values:       "steadfastness,forthrightness",
-		StringValues: "tensile_strength,flexibility",
-		ValuesFiles:  []string{"/root/price_inventory.yml"},
 		Namespace: "outer",
-		Stdout:       os.Stdout,
+		Stdout:    &stdout,
-		Stderr:       os.Stderr,
+		Stderr:    &stderr,
 	}
 
 	stepOne.EXPECT().
@@ -63,6 +60,7 @@ func (suite *PlanTestSuite) TestNewPlan() {
 
 func (suite *PlanTestSuite) TestNewPlanAbortsOnError() {
 	ctrl := gomock.NewController(suite.T())
+	defer ctrl.Finish()
 	stepOne := NewMockStep(ctrl)
 	stepTwo := NewMockStep(ctrl)
 
@@ -85,54 +83,264 @@ func (suite *PlanTestSuite) TestNewPlanAbortsOnError() {
 	suite.EqualError(err, "while preparing *helm.MockStep step: I'm starry Dave, aye, cat blew that")
 }
 
+func (suite *PlanTestSuite) TestExecute() {
+	ctrl := gomock.NewController(suite.T())
+	defer ctrl.Finish()
+	stepOne := NewMockStep(ctrl)
+	stepTwo := NewMockStep(ctrl)
+
+	runCfg := run.Config{}
+
+	plan := Plan{
+		steps:  []Step{stepOne, stepTwo},
+		runCfg: runCfg,
+	}
+
+	stepOne.EXPECT().
+		Execute(runCfg).
+		Times(1)
+	stepTwo.EXPECT().
+		Execute(runCfg).
+		Times(1)
+
+	suite.NoError(plan.Execute())
+}
+
+func (suite *PlanTestSuite) TestExecuteAbortsOnError() {
+	ctrl := gomock.NewController(suite.T())
+	defer ctrl.Finish()
+	stepOne := NewMockStep(ctrl)
+	stepTwo := NewMockStep(ctrl)
+
+	runCfg := run.Config{}
+
+	plan := Plan{
+		steps:  []Step{stepOne, stepTwo},
+		runCfg: runCfg,
+	}
+
+	stepOne.EXPECT().
+		Execute(runCfg).
+		Times(1).
+		Return(fmt.Errorf("oh, he'll gnaw"))
+
+	err := plan.Execute()
+	suite.EqualError(err, "while executing *helm.MockStep step: oh, he'll gnaw")
+}
+
 func (suite *PlanTestSuite) TestUpgrade() {
+	cfg := Config{
+		ChartVersion:  "seventeen",
+		DryRun:        true,
+		Wait:          true,
+		Values:        "steadfastness,forthrightness",
+		StringValues:  "tensile_strength,flexibility",
+		ValuesFiles:   []string{"/root/price_inventory.yml"},
+		ReuseValues:   true,
+		Timeout:       "go sit in the corner",
+		Chart:         "billboard_top_100",
+		Release:       "post_malone_circles",
+		Force:         true,
+		AtomicUpgrade: true,
+		CleanupOnFail: true,
+	}
+
+	steps := upgrade(cfg)
+	suite.Require().Equal(2, len(steps), "upgrade should return 2 steps")
+	suite.Require().IsType(&run.InitKube{}, steps[0])
+
+	suite.Require().IsType(&run.Upgrade{}, steps[1])
+	upgrade, _ := steps[1].(*run.Upgrade)
+
+	expected := &run.Upgrade{
+		Chart:         cfg.Chart,
+		Release:       cfg.Release,
+		ChartVersion:  cfg.ChartVersion,
+		DryRun:        true,
+		Wait:          cfg.Wait,
+		Values:        "steadfastness,forthrightness",
+		StringValues:  "tensile_strength,flexibility",
+		ValuesFiles:   []string{"/root/price_inventory.yml"},
+		ReuseValues:   cfg.ReuseValues,
+		Timeout:       cfg.Timeout,
+		Force:         cfg.Force,
+		Atomic:        true,
+		CleanupOnFail: true,
+	}
+
+	suite.Equal(expected, upgrade)
+}
+
+func (suite *PlanTestSuite) TestUpgradeWithUpdateDependencies() {
+	cfg := Config{
+		UpdateDependencies: true,
+	}
+	steps := upgrade(cfg)
+	suite.Require().Equal(3, len(steps), "upgrade should have a third step when DepUpdate is true")
+	suite.IsType(&run.InitKube{}, steps[0])
+	suite.IsType(&run.DepUpdate{}, steps[1])
+}
+
+func (suite *PlanTestSuite) TestUpgradeWithAddRepos() {
+	cfg := Config{
+		AddRepos: []string{
+			"machine=https://github.com/harold_finch/themachine",
+		},
+	}
+	steps := upgrade(cfg)
+	suite.Require().True(len(steps) > 1, "upgrade should generate at least two steps")
+	suite.IsType(&run.AddRepo{}, steps[1])
+}
+
+func (suite *PlanTestSuite) TestUninstall() {
+	cfg := Config{
+		KubeToken:      "b2YgbXkgYWZmZWN0aW9u",
+		SkipTLSVerify:  true,
+		Certificate:    "cHJvY2xhaW1zIHdvbmRlcmZ1bCBmcmllbmRzaGlw",
+		APIServer:      "98.765.43.21",
+		ServiceAccount: "greathelm",
+		DryRun:         true,
+		Timeout:        "think about what you did",
+		Release:        "jetta_id_love_to_change_the_world",
+		KeepHistory:    true,
+	}
+
+	steps := uninstall(cfg)
+	suite.Require().Equal(2, len(steps), "uninstall should return 2 steps")
+
+	suite.Require().IsType(&run.InitKube{}, steps[0])
+	init, _ := steps[0].(*run.InitKube)
+	var expected Step = &run.InitKube{
+		SkipTLSVerify:  true,
+		Certificate:    "cHJvY2xhaW1zIHdvbmRlcmZ1bCBmcmllbmRzaGlw",
+		APIServer:      "98.765.43.21",
+		ServiceAccount: "greathelm",
+		Token:          "b2YgbXkgYWZmZWN0aW9u",
+		TemplateFile:   kubeConfigTemplate,
+		ConfigFile:     kubeConfigFile,
+	}
+
+	suite.Equal(expected, init)
+
+	suite.Require().IsType(&run.Uninstall{}, steps[1])
+	actual, _ := steps[1].(*run.Uninstall)
+	expected = &run.Uninstall{
+		Release:     "jetta_id_love_to_change_the_world",
+		DryRun:      true,
+		KeepHistory: true,
+	}
+	suite.Equal(expected, actual)
+}
+
+func (suite *PlanTestSuite) TestUninstallWithUpdateDependencies() {
+	cfg := Config{
+		UpdateDependencies: true,
+	}
+	steps := uninstall(cfg)
+	suite.Require().Equal(3, len(steps), "uninstall should have a third step when DepUpdate is true")
+	suite.IsType(&run.InitKube{}, steps[0])
+	suite.IsType(&run.DepUpdate{}, steps[1])
+}
+
+func (suite *PlanTestSuite) TestInitKube() {
 	cfg := Config{
 		KubeToken:      "cXVlZXIgY2hhcmFjdGVyCg==",
 		SkipTLSVerify:  true,
 		Certificate:    "b2Ygd29rZW5lc3MK",
 		APIServer:      "123.456.78.9",
 		ServiceAccount: "helmet",
-		ChartVersion:   "seventeen",
-		Wait:           true,
-		ReuseValues:    true,
-		Timeout:        "go sit in the corner",
-		Chart:          "billboard_top_100",
-		Release:        "post_malone_circles",
-		Force:          true,
 	}
 
-	steps := upgrade(cfg)
+	steps := initKube(cfg)
-
+	suite.Require().Equal(1, len(steps), "initKube should return one step")
-	suite.Equal(2, len(steps))
-
 	suite.Require().IsType(&run.InitKube{}, steps[0])
 	init, _ := steps[0].(*run.InitKube)
 
-	var expected Step = &run.InitKube{
+	expected := &run.InitKube{
-		SkipTLSVerify:  cfg.SkipTLSVerify,
+		SkipTLSVerify:  true,
-		Certificate:    cfg.Certificate,
+		Certificate:    "b2Ygd29rZW5lc3MK",
-		APIServer:      cfg.APIServer,
+		APIServer:      "123.456.78.9",
-		ServiceAccount: cfg.ServiceAccount,
+		ServiceAccount: "helmet",
-		Token:          cfg.KubeToken,
+		Token:          "cXVlZXIgY2hhcmFjdGVyCg==",
 		TemplateFile:   kubeConfigTemplate,
+		ConfigFile:     kubeConfigFile,
 	}
-
 	suite.Equal(expected, init)
-
-	suite.Require().IsType(&run.Upgrade{}, steps[1])
-	upgrade, _ := steps[1].(*run.Upgrade)
-
-	expected = &run.Upgrade{
-		Chart:        cfg.Chart,
-		Release:      cfg.Release,
-		ChartVersion: cfg.ChartVersion,
-		Wait:         cfg.Wait,
-		ReuseValues:  cfg.ReuseValues,
-		Timeout:      cfg.Timeout,
-		Force:        cfg.Force,
 }
 
-	suite.Equal(expected, upgrade)
+func (suite *PlanTestSuite) TestDepUpdate() {
+	cfg := Config{
+		UpdateDependencies: true,
+		Chart:              "scatterplot",
+	}
+
+	steps := depUpdate(cfg)
+	suite.Require().Equal(1, len(steps), "depUpdate should return one step")
+	suite.Require().IsType(&run.DepUpdate{}, steps[0])
+	update, _ := steps[0].(*run.DepUpdate)
+
+	expected := &run.DepUpdate{
+		Chart: "scatterplot",
+	}
+	suite.Equal(expected, update)
+}
+
+func (suite *PlanTestSuite) TestAddRepos() {
+	cfg := Config{
+		AddRepos: []string{
+			"first=https://add.repos/one",
+			"second=https://add.repos/two",
+		},
+	}
+	steps := addRepos(cfg)
+	suite.Require().Equal(2, len(steps), "addRepos should add one step per repo")
+	suite.Require().IsType(&run.AddRepo{}, steps[0])
+	suite.Require().IsType(&run.AddRepo{}, steps[1])
+	first := steps[0].(*run.AddRepo)
+	second := steps[1].(*run.AddRepo)
+
+	suite.Equal(first.Repo, "first=https://add.repos/one")
+	suite.Equal(second.Repo, "second=https://add.repos/two")
+}
+
+func (suite *PlanTestSuite) TestLint() {
+	cfg := Config{
+		Chart:        "./flow",
+		Values:       "steadfastness,forthrightness",
+		StringValues: "tensile_strength,flexibility",
+		ValuesFiles:  []string{"/root/price_inventory.yml"},
+		LintStrictly: true,
+	}
+
+	steps := lint(cfg)
+	suite.Equal(1, len(steps))
+
+	want := &run.Lint{
+		Chart:        "./flow",
+		Values:       "steadfastness,forthrightness",
+		StringValues: "tensile_strength,flexibility",
+		ValuesFiles:  []string{"/root/price_inventory.yml"},
+		Strict:       true,
+	}
+	suite.Equal(want, steps[0])
+}
+
+func (suite *PlanTestSuite) TestLintWithUpdateDependencies() {
+	cfg := Config{
+		UpdateDependencies: true,
+	}
+	steps := lint(cfg)
+	suite.Require().Equal(2, len(steps), "lint should have a second step when DepUpdate is true")
+	suite.IsType(&run.DepUpdate{}, steps[0])
+}
+
+func (suite *PlanTestSuite) TestLintWithAddRepos() {
+	cfg := Config{
+		AddRepos: []string{"friendczar=https://github.com/logan_pierce/friendczar"},
+	}
+	steps := lint(cfg)
+	suite.Require().True(len(steps) > 0, "lint should return at least one step")
+	suite.IsType(&run.AddRepo{}, steps[0])
 }
 
 func (suite *PlanTestSuite) TestDeterminePlanUpgradeCommand() {
@@ -154,6 +362,40 @@ func (suite *PlanTestSuite) TestDeterminePlanUpgradeFromDroneEvent() {
 	}
 }
 
+func (suite *PlanTestSuite) TestDeterminePlanUninstallCommand() {
+	cfg := Config{
+		Command: "uninstall",
+	}
+	stepsMaker := determineSteps(cfg)
+	suite.Same(&uninstall, stepsMaker)
+}
+
+// helm_command = delete is provided as an alias for backwards-compatibility with drone-helm
+func (suite *PlanTestSuite) TestDeterminePlanDeleteCommand() {
+	cfg := Config{
+		Command: "delete",
+	}
+	stepsMaker := determineSteps(cfg)
+	suite.Same(&uninstall, stepsMaker)
+}
+
+func (suite *PlanTestSuite) TestDeterminePlanDeleteFromDroneEvent() {
+	cfg := Config{
+		DroneEvent: "delete",
+	}
+	stepsMaker := determineSteps(cfg)
+	suite.Same(&uninstall, stepsMaker)
+}
+
+func (suite *PlanTestSuite) TestDeterminePlanLintCommand() {
+	cfg := Config{
+		Command: "lint",
+	}
+
+	stepsMaker := determineSteps(cfg)
+	suite.Same(&lint, stepsMaker)
+}
+
 func (suite *PlanTestSuite) TestDeterminePlanHelpCommand() {
 	cfg := Config{
 		Command: "help",

internal/run/addrepo.go

@@ -0,0 +1,52 @@
+package run
+
+import (
+	"fmt"
+	"strings"
+)
+
+// AddRepo is an execution step that calls `helm repo add` when executed.
+type AddRepo struct {
+	Repo string
+	cmd  cmd
+}
+
+// Execute executes the `helm repo add` command.
+func (a *AddRepo) Execute(_ Config) error {
+	return a.cmd.Run()
+}
+
+// Prepare gets the AddRepo ready to execute.
+func (a *AddRepo) Prepare(cfg Config) error {
+	if a.Repo == "" {
+		return fmt.Errorf("repo is required")
+	}
+	split := strings.SplitN(a.Repo, "=", 2)
+	if len(split) != 2 {
+		return fmt.Errorf("bad repo spec '%s'", a.Repo)
+	}
+
+	name := split[0]
+	url := split[1]
+
+	args := make([]string, 0)
+
+	if cfg.Namespace != "" {
+		args = append(args, "--namespace", cfg.Namespace)
+	}
+	if cfg.Debug {
+		args = append(args, "--debug")
+	}
+
+	args = append(args, "repo", "add", name, url)
+
+	a.cmd = command(helmBin, args...)
+	a.cmd.Stdout(cfg.Stdout)
+	a.cmd.Stderr(cfg.Stderr)
+
+	if cfg.Debug {
+		fmt.Fprintf(cfg.Stderr, "Generated command: '%s'\n", a.cmd.String())
+	}
+
+	return nil
+}

internal/run/addrepo_test.go

@@ -0,0 +1,141 @@
+package run
+
+import (
+	"fmt"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/suite"
+	"strings"
+	"testing"
+)
+
+type AddRepoTestSuite struct {
+	suite.Suite
+	ctrl            *gomock.Controller
+	mockCmd         *Mockcmd
+	originalCommand func(string, ...string) cmd
+	commandPath     string
+	commandArgs     []string
+}
+
+func (suite *AddRepoTestSuite) BeforeTest(_, _ string) {
+	suite.ctrl = gomock.NewController(suite.T())
+	suite.mockCmd = NewMockcmd(suite.ctrl)
+
+	suite.originalCommand = command
+	command = func(path string, args ...string) cmd {
+		suite.commandPath = path
+		suite.commandArgs = args
+		return suite.mockCmd
+	}
+}
+
+func (suite *AddRepoTestSuite) AfterTest(_, _ string) {
+	suite.ctrl.Finish()
+	command = suite.originalCommand
+}
+
+func TestAddRepoTestSuite(t *testing.T) {
+	suite.Run(t, new(AddRepoTestSuite))
+}
+
+func (suite *AddRepoTestSuite) TestPrepareAndExecute() {
+	stdout := strings.Builder{}
+	stderr := strings.Builder{}
+	cfg := Config{
+		Stdout: &stdout,
+		Stderr: &stderr,
+	}
+	a := AddRepo{
+		Repo: "edeath=https://github.com/n_marks/e-death",
+	}
+
+	suite.mockCmd.EXPECT().
+		Stdout(&stdout).
+		Times(1)
+	suite.mockCmd.EXPECT().
+		Stderr(&stderr).
+		Times(1)
+
+	suite.Require().NoError(a.Prepare(cfg))
+	suite.Equal(helmBin, suite.commandPath)
+	suite.Equal([]string{"repo", "add", "edeath", "https://github.com/n_marks/e-death"}, suite.commandArgs)
+
+	suite.mockCmd.EXPECT().
+		Run().
+		Times(1)
+
+	suite.Require().NoError(a.Execute(cfg))
+
+}
+
+func (suite *AddRepoTestSuite) TestPrepareRepoIsRequired() {
+	// These aren't really expected, but allowing them gives clearer test-failure messages
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+	cfg := Config{}
+	a := AddRepo{}
+
+	err := a.Prepare(cfg)
+	suite.EqualError(err, "repo is required")
+}
+
+func (suite *AddRepoTestSuite) TestPrepareMalformedRepo() {
+	a := AddRepo{
+		Repo: "dwim",
+	}
+	err := a.Prepare(Config{})
+	suite.EqualError(err, "bad repo spec 'dwim'")
+}
+
+func (suite *AddRepoTestSuite) TestPrepareWithEqualSignInURL() {
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+	a := AddRepo{
+		Repo: "samaritan=https://github.com/arthur_claypool/samaritan?version=2.1",
+	}
+	suite.NoError(a.Prepare(Config{}))
+	suite.Contains(suite.commandArgs, "https://github.com/arthur_claypool/samaritan?version=2.1")
+}
+
+func (suite *AddRepoTestSuite) TestNamespaceFlag() {
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+	cfg := Config{
+		Namespace: "alliteration",
+	}
+	a := AddRepo{
+		Repo: "edeath=https://github.com/theater_guy/e-death",
+	}
+
+	suite.NoError(a.Prepare(cfg))
+	suite.Equal(suite.commandPath, helmBin)
+	suite.Equal(suite.commandArgs, []string{"--namespace", "alliteration",
+		"repo", "add", "edeath", "https://github.com/theater_guy/e-death"})
+}
+
+func (suite *AddRepoTestSuite) TestDebugFlag() {
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	stderr := strings.Builder{}
+
+	command = func(path string, args ...string) cmd {
+		suite.mockCmd.EXPECT().
+			String().
+			Return(fmt.Sprintf("%s %s", path, strings.Join(args, " ")))
+
+		return suite.mockCmd
+	}
+
+	cfg := Config{
+		Debug:  true,
+		Stderr: &stderr,
+	}
+	a := AddRepo{
+		Repo: "edeath=https://github.com/the_bug/e-death",
+	}
+
+	suite.Require().NoError(a.Prepare(cfg))
+	suite.Equal(fmt.Sprintf("Generated command: '%s --debug "+
+		"repo add edeath https://github.com/the_bug/e-death'\n", helmBin), stderr.String())
+}

internal/run/config.go

@@ -7,10 +7,6 @@ import (
 // Config contains configuration applicable to all helm commands
 type Config struct {
 	Debug     bool
-	KubeConfig   string
-	Values       string
-	StringValues string
-	ValuesFiles  []string
 	Namespace string
 	Stdout    io.Writer
 	Stderr    io.Writer

internal/run/depupdate.go

@@ -0,0 +1,44 @@
+package run
+
+import (
+	"fmt"
+)
+
+// DepUpdate is an execution step that calls `helm dependency update` when executed.
+type DepUpdate struct {
+	Chart string
+	cmd   cmd
+}
+
+// Execute executes the `helm upgrade` command.
+func (d *DepUpdate) Execute(_ Config) error {
+	return d.cmd.Run()
+}
+
+// Prepare gets the DepUpdate ready to execute.
+func (d *DepUpdate) Prepare(cfg Config) error {
+	if d.Chart == "" {
+		return fmt.Errorf("chart is required")
+	}
+
+	args := make([]string, 0)
+
+	if cfg.Namespace != "" {
+		args = append(args, "--namespace", cfg.Namespace)
+	}
+	if cfg.Debug {
+		args = append(args, "--debug")
+	}
+
+	args = append(args, "dependency", "update", d.Chart)
+
+	d.cmd = command(helmBin, args...)
+	d.cmd.Stdout(cfg.Stdout)
+	d.cmd.Stderr(cfg.Stderr)
+
+	if cfg.Debug {
+		fmt.Fprintf(cfg.Stderr, "Generated command: '%s'\n", d.cmd.String())
+	}
+
+	return nil
+}

internal/run/depupdate_test.go

@@ -0,0 +1,128 @@
+package run
+
+import (
+	"fmt"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/suite"
+	"strings"
+	"testing"
+)
+
+type DepUpdateTestSuite struct {
+	suite.Suite
+	ctrl            *gomock.Controller
+	mockCmd         *Mockcmd
+	originalCommand func(string, ...string) cmd
+}
+
+func (suite *DepUpdateTestSuite) BeforeTest(_, _ string) {
+	suite.ctrl = gomock.NewController(suite.T())
+	suite.mockCmd = NewMockcmd(suite.ctrl)
+
+	suite.originalCommand = command
+	command = func(path string, args ...string) cmd { return suite.mockCmd }
+}
+
+func (suite *DepUpdateTestSuite) AfterTest(_, _ string) {
+	command = suite.originalCommand
+}
+
+func TestDepUpdateTestSuite(t *testing.T) {
+	suite.Run(t, new(DepUpdateTestSuite))
+}
+
+func (suite *DepUpdateTestSuite) TestPrepareAndExecute() {
+	defer suite.ctrl.Finish()
+
+	stdout := strings.Builder{}
+	stderr := strings.Builder{}
+	cfg := Config{
+		Stdout: &stdout,
+		Stderr: &stderr,
+	}
+
+	command = func(path string, args ...string) cmd {
+		suite.Equal(helmBin, path)
+		suite.Equal([]string{"dependency", "update", "your_top_songs_2019"}, args)
+
+		return suite.mockCmd
+	}
+	suite.mockCmd.EXPECT().
+		Stdout(&stdout)
+	suite.mockCmd.EXPECT().
+		Stderr(&stderr)
+	suite.mockCmd.EXPECT().
+		Run().
+		Times(1)
+
+	d := DepUpdate{
+		Chart: "your_top_songs_2019",
+	}
+
+	suite.Require().NoError(d.Prepare(cfg))
+	suite.NoError(d.Execute(cfg))
+}
+
+func (suite *DepUpdateTestSuite) TestPrepareNamespaceFlag() {
+	defer suite.ctrl.Finish()
+
+	cfg := Config{
+		Namespace: "spotify",
+	}
+
+	command = func(path string, args ...string) cmd {
+		suite.Equal([]string{"--namespace", "spotify", "dependency", "update", "your_top_songs_2019"}, args)
+
+		return suite.mockCmd
+	}
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	d := DepUpdate{
+		Chart: "your_top_songs_2019",
+	}
+
+	suite.Require().NoError(d.Prepare(cfg))
+}
+
+func (suite *DepUpdateTestSuite) TestPrepareDebugFlag() {
+	defer suite.ctrl.Finish()
+
+	stdout := strings.Builder{}
+	stderr := strings.Builder{}
+	cfg := Config{
+		Debug:  true,
+		Stdout: &stdout,
+		Stderr: &stderr,
+	}
+
+	command = func(path string, args ...string) cmd {
+		suite.mockCmd.EXPECT().
+			String().
+			Return(fmt.Sprintf("%s %s", path, strings.Join(args, " ")))
+
+		return suite.mockCmd
+	}
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	d := DepUpdate{
+		Chart: "your_top_songs_2019",
+	}
+
+	suite.Require().NoError(d.Prepare(cfg))
+
+	want := fmt.Sprintf("Generated command: '%s --debug dependency update your_top_songs_2019'\n", helmBin)
+	suite.Equal(want, stderr.String())
+	suite.Equal("", stdout.String())
+}
+
+func (suite *DepUpdateTestSuite) TestPrepareChartRequired() {
+	d := DepUpdate{}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	err := d.Prepare(Config{})
+	suite.EqualError(err, "chart is required")
+}

internal/run/help.go

@@ -6,12 +6,20 @@ import (
 
 // Help is a step in a helm Plan that calls `helm help`.
 type Help struct {
+	HelmCommand string
 	cmd         cmd
 }
 
 // Execute executes the `helm help` command.
-func (h *Help) Execute(_ Config) error {
+func (h *Help) Execute(cfg Config) error {
-	return h.cmd.Run()
+	if err := h.cmd.Run(); err != nil {
+		return fmt.Errorf("while running '%s': %w", h.cmd.String(), err)
+	}
+
+	if h.HelmCommand == "help" {
+		return nil
+	}
+	return fmt.Errorf("unknown command '%s'", h.HelmCommand)
 }
 
 // Prepare gets the Help ready to execute.

internal/run/help_test.go

@@ -38,9 +38,6 @@ func (suite *HelpTestSuite) TestPrepare() {
 		Stdout(&stdout)
 	mCmd.EXPECT().
 		Stderr(&stderr)
-	mCmd.EXPECT().
-		Run().
-		Times(1)
 
 	cfg := Config{
 		Stdout: &stdout,
@@ -49,8 +46,32 @@ func (suite *HelpTestSuite) TestPrepare() {
 
 	h := Help{}
 	err := h.Prepare(cfg)
-	suite.Require().Nil(err)
+	suite.NoError(err)
-	h.Execute(cfg)
+}
+
+func (suite *HelpTestSuite) TestExecute() {
+	ctrl := gomock.NewController(suite.T())
+	defer ctrl.Finish()
+	mCmd := NewMockcmd(ctrl)
+	originalCommand := command
+	command = func(_ string, _ ...string) cmd {
+		return mCmd
+	}
+	defer func() { command = originalCommand }()
+
+	mCmd.EXPECT().
+		Run().
+		Times(2)
+
+	cfg := Config{}
+	help := Help{
+		HelmCommand: "help",
+		cmd:         mCmd,
+	}
+	suite.NoError(help.Execute(cfg))
+
+	help.HelmCommand = "get down on friday"
+	suite.EqualError(help.Execute(cfg), "unknown command 'get down on friday'")
 }
 
 func (suite *HelpTestSuite) TestPrepareDebugFlag() {

internal/run/initkube.go

@@ -16,6 +16,7 @@ type InitKube struct {
 	ServiceAccount string
 	Token          string
 	TemplateFile   string
+	ConfigFile     string
 
 	template   *template.Template
 	configFile io.WriteCloser
@@ -34,7 +35,7 @@ type kubeValues struct {
 // Execute generates a kubernetes config file from drone-helm3's template.
 func (i *InitKube) Execute(cfg Config) error {
 	if cfg.Debug {
-		fmt.Fprintf(cfg.Stderr, "writing kubeconfig file to %s\n", cfg.KubeConfig)
+		fmt.Fprintf(cfg.Stderr, "writing kubeconfig file to %s\n", i.ConfigFile)
 	}
 	defer i.configFile.Close()
 	return i.template.Execute(i.configFile, i.values)
@@ -50,9 +51,6 @@ func (i *InitKube) Prepare(cfg Config) error {
 	if i.Token == "" {
 		return errors.New("token is needed to deploy")
 	}
-	if i.Certificate == "" && !i.SkipTLSVerify {
-		return errors.New("certificate is needed to deploy")
-	}
 
 	if i.ServiceAccount == "" {
 		i.ServiceAccount = "helm"
@@ -76,16 +74,16 @@ func (i *InitKube) Prepare(cfg Config) error {
 	}
 
 	if cfg.Debug {
-		if _, err := os.Stat(cfg.KubeConfig); err != nil {
+		if _, err := os.Stat(i.ConfigFile); err != nil {
 			// non-nil err here isn't an actual error state; the kubeconfig just doesn't exist
 			fmt.Fprint(cfg.Stderr, "creating ")
 		} else {
 			fmt.Fprint(cfg.Stderr, "truncating ")
 		}
-		fmt.Fprintf(cfg.Stderr, "kubeconfig file at %s\n", cfg.KubeConfig)
+		fmt.Fprintf(cfg.Stderr, "kubeconfig file at %s\n", i.ConfigFile)
 	}
 
-	i.configFile, err = os.Create(cfg.KubeConfig)
+	i.configFile, err = os.Create(i.ConfigFile)
 	if err != nil {
 		return fmt.Errorf("could not open kubeconfig file for writing: %w", err)
 	}

internal/run/initkube_test.go

@@ -1,12 +1,12 @@
 package run
 
 import (
+	"github.com/stretchr/testify/suite"
+	yaml "gopkg.in/yaml.v2"
 	"io/ioutil"
 	"os"
-	"text/template"
-	// "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
 	"testing"
+	"text/template"
 )
 
 type InitKubeTestSuite struct {
@@ -34,10 +34,10 @@ namespace: {{ .Namespace }}
 		Certificate:  "CCNA",
 		Token:        "Aspire virtual currency",
 		TemplateFile: templateFile.Name(),
+		ConfigFile:   configFile.Name(),
 	}
 	cfg := Config{
 		Namespace: "Cisco",
-		KubeConfig: configFile.Name(),
 	}
 	err = init.Prepare(cfg)
 	suite.Require().Nil(err)
@@ -58,6 +58,59 @@ namespace: Cisco
 	suite.Equal(want, string(conf))
 }
 
+func (suite *InitKubeTestSuite) TestExecuteGeneratesConfig() {
+	configFile, err := tempfile("kubeconfig********.yml", "")
+	defer os.Remove(configFile.Name())
+	suite.Require().NoError(err)
+
+	cfg := Config{
+		Namespace: "marshmallow",
+	}
+	init := InitKube{
+		ConfigFile:     configFile.Name(),
+		TemplateFile:   "../../assets/kubeconfig.tpl", // the actual kubeconfig template
+		APIServer:      "https://kube.cluster/peanut",
+		ServiceAccount: "chef",
+		Token:          "eWVhaCB3ZSB0b2tpbic=",
+		Certificate:    "d293LCB5b3UgYXJlIHNvIGNvb2wgZm9yIHNtb2tpbmcgd2VlZCDwn5mE",
+	}
+	suite.Require().NoError(init.Prepare(cfg))
+	suite.Require().NoError(init.Execute(cfg))
+
+	contents, err := ioutil.ReadFile(configFile.Name())
+	suite.Require().NoError(err)
+
+	// each setting should be reflected in the generated file
+	expectations := []string{
+		"namespace: marshmallow",
+		"server: https://kube.cluster/peanut",
+		"user: chef",
+		"name: chef",
+		"token: eWVhaCB3ZSB0b2tpbic",
+		"certificate-authority-data: d293LCB5b3UgYXJlIHNvIGNvb2wgZm9yIHNtb2tpbmcgd2VlZCDwn5mE",
+	}
+	for _, expected := range expectations {
+		suite.Contains(string(contents), expected)
+	}
+
+	// the generated config should be valid yaml, with no repeated keys
+	conf := map[string]interface{}{}
+	suite.NoError(yaml.UnmarshalStrict(contents, &conf))
+
+	// test the other branch of the certificate/SkipTLSVerify conditional
+	init.SkipTLSVerify = true
+	init.Certificate = ""
+
+	suite.Require().NoError(init.Prepare(cfg))
+	suite.Require().NoError(init.Execute(cfg))
+	contents, err = ioutil.ReadFile(configFile.Name())
+	suite.Require().NoError(err)
+	suite.Contains(string(contents), "insecure-skip-tls-verify: true")
+
+	conf = map[string]interface{}{}
+	suite.NoError(yaml.UnmarshalStrict(contents, &conf))
+}
+
 func (suite *InitKubeTestSuite) TestPrepareParseError() {
 	templateFile, err := tempfile("kubeconfig********.yml.tpl", `{{ NonexistentFunction }}`)
 	defer os.Remove(templateFile.Name())
@@ -95,11 +148,10 @@ func (suite *InitKubeTestSuite) TestPrepareCannotOpenDestinationFile() {
 		Certificate:  "CCNA",
 		Token:        "Aspire virtual currency",
 		TemplateFile: templateFile.Name(),
+		ConfigFile:   "/usr/foreign/exclude/kubeprofig",
 	}
 
-	cfg := Config{
+	cfg := Config{}
-		KubeConfig: "/usr/foreign/exclude/kubeprofig",
-	}
 	err = init.Prepare(cfg)
 	suite.Error(err)
 	suite.Regexp("could not open .* for writing: .* no such file or directory", err)
@@ -120,11 +172,10 @@ func (suite *InitKubeTestSuite) TestPrepareRequiredConfig() {
 		Certificate:  "CCNA",
 		Token:        "Aspire virtual currency",
 		TemplateFile: templateFile.Name(),
+		ConfigFile:   configFile.Name(),
 	}
 
-	cfg := Config{
+	cfg := Config{}
-		KubeConfig: configFile.Name(),
-	}
 
 	suite.NoError(init.Prepare(cfg)) // consistency check; we should be starting in a happy state
 
@@ -134,13 +185,6 @@ func (suite *InitKubeTestSuite) TestPrepareRequiredConfig() {
 	init.APIServer = "Sysadmin"
 	init.Token = ""
 	suite.Error(init.Prepare(cfg), "Token should be required.")
-
-	init.Token = "Aspire virtual currency"
-	init.Certificate = ""
-	suite.Error(init.Prepare(cfg), "Certificate should be required.")
-
-	init.SkipTLSVerify = true
-	suite.NoError(init.Prepare(cfg), "Certificate should not be required if SkipTLSVerify is true")
 }
 
 func (suite *InitKubeTestSuite) TestPrepareDefaultsServiceAccount() {
@@ -157,11 +201,10 @@ func (suite *InitKubeTestSuite) TestPrepareDefaultsServiceAccount() {
 		Certificate:  "CCNA",
 		Token:        "Aspire virtual currency",
 		TemplateFile: templateFile.Name(),
+		ConfigFile:   configFile.Name(),
 	}
 
-	cfg := Config{
+	cfg := Config{}
-		KubeConfig: configFile.Name(),
-	}
 
 	init.Prepare(cfg)
 	suite.Equal("helm", init.ServiceAccount)

internal/run/lint.go

@@ -0,0 +1,63 @@
+package run
+
+import (
+	"fmt"
+)
+
+// Lint is an execution step that calls `helm lint` when executed.
+type Lint struct {
+	Chart        string
+	Values       string
+	StringValues string
+	ValuesFiles  []string
+	Strict       bool
+	cmd          cmd
+}
+
+// Execute executes the `helm lint` command.
+func (l *Lint) Execute(_ Config) error {
+	return l.cmd.Run()
+}
+
+// Prepare gets the Lint ready to execute.
+func (l *Lint) Prepare(cfg Config) error {
+	if l.Chart == "" {
+		return fmt.Errorf("chart is required")
+	}
+
+	args := make([]string, 0)
+
+	if cfg.Namespace != "" {
+		args = append(args, "--namespace", cfg.Namespace)
+	}
+	if cfg.Debug {
+		args = append(args, "--debug")
+	}
+
+	args = append(args, "lint")
+
+	if l.Values != "" {
+		args = append(args, "--set", l.Values)
+	}
+	if l.StringValues != "" {
+		args = append(args, "--set-string", l.StringValues)
+	}
+	for _, vFile := range l.ValuesFiles {
+		args = append(args, "--values", vFile)
+	}
+	if l.Strict {
+		args = append(args, "--strict")
+	}
+
+	args = append(args, l.Chart)
+
+	l.cmd = command(helmBin, args...)
+	l.cmd.Stdout(cfg.Stdout)
+	l.cmd.Stderr(cfg.Stderr)
+
+	if cfg.Debug {
+		fmt.Fprintf(cfg.Stderr, "Generated command: '%s'\n", l.cmd.String())
+	}
+
+	return nil
+}

internal/run/lint_test.go

@@ -0,0 +1,170 @@
+package run
+
+import (
+	"fmt"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/suite"
+	"strings"
+	"testing"
+)
+
+type LintTestSuite struct {
+	suite.Suite
+	ctrl            *gomock.Controller
+	mockCmd         *Mockcmd
+	originalCommand func(string, ...string) cmd
+}
+
+func (suite *LintTestSuite) BeforeTest(_, _ string) {
+	suite.ctrl = gomock.NewController(suite.T())
+	suite.mockCmd = NewMockcmd(suite.ctrl)
+
+	suite.originalCommand = command
+	command = func(path string, args ...string) cmd { return suite.mockCmd }
+}
+
+func (suite *LintTestSuite) AfterTest(_, _ string) {
+	command = suite.originalCommand
+}
+
+func TestLintTestSuite(t *testing.T) {
+	suite.Run(t, new(LintTestSuite))
+}
+
+func (suite *LintTestSuite) TestPrepareAndExecute() {
+	defer suite.ctrl.Finish()
+
+	stdout := strings.Builder{}
+	stderr := strings.Builder{}
+
+	l := Lint{
+		Chart: "./epic/mychart",
+	}
+	cfg := Config{
+		Stdout: &stdout,
+		Stderr: &stderr,
+	}
+
+	command = func(path string, args ...string) cmd {
+		suite.Equal(helmBin, path)
+		suite.Equal([]string{"lint", "./epic/mychart"}, args)
+
+		return suite.mockCmd
+	}
+
+	suite.mockCmd.EXPECT().
+		Stdout(&stdout)
+	suite.mockCmd.EXPECT().
+		Stderr(&stderr)
+	suite.mockCmd.EXPECT().
+		Run().
+		Times(1)
+
+	err := l.Prepare(cfg)
+	suite.Require().Nil(err)
+	l.Execute(cfg)
+}
+
+func (suite *LintTestSuite) TestPrepareRequiresChart() {
+	// These aren't really expected, but allowing them gives clearer test-failure messages
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	cfg := Config{}
+	l := Lint{}
+
+	err := l.Prepare(cfg)
+	suite.EqualError(err, "chart is required", "Chart should be mandatory")
+}
+
+func (suite *LintTestSuite) TestPrepareWithLintFlags() {
+	defer suite.ctrl.Finish()
+
+	cfg := Config{}
+
+	l := Lint{
+		Chart:        "./uk/top_40",
+		Values:       "width=5",
+		StringValues: "version=2.0",
+		ValuesFiles:  []string{"/usr/local/underrides", "/usr/local/overrides"},
+		Strict:       true,
+	}
+
+	command = func(path string, args ...string) cmd {
+		suite.Equal(helmBin, path)
+		suite.Equal([]string{"lint",
+			"--set", "width=5",
+			"--set-string", "version=2.0",
+			"--values", "/usr/local/underrides",
+			"--values", "/usr/local/overrides",
+			"--strict",
+			"./uk/top_40"}, args)
+
+		return suite.mockCmd
+	}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	err := l.Prepare(cfg)
+	suite.Require().Nil(err)
+}
+
+func (suite *LintTestSuite) TestPrepareWithDebugFlag() {
+	defer suite.ctrl.Finish()
+
+	stderr := strings.Builder{}
+
+	cfg := Config{
+		Debug:  true,
+		Stderr: &stderr,
+	}
+
+	l := Lint{
+		Chart: "./scotland/top_40",
+	}
+
+	command = func(path string, args ...string) cmd {
+		suite.mockCmd.EXPECT().
+			String().
+			Return(fmt.Sprintf("%s %s", path, strings.Join(args, " ")))
+
+		return suite.mockCmd
+	}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any())
+	suite.mockCmd.EXPECT().Stderr(&stderr)
+
+	err := l.Prepare(cfg)
+	suite.Require().Nil(err)
+
+	want := fmt.Sprintf("Generated command: '%s --debug lint ./scotland/top_40'\n", helmBin)
+	suite.Equal(want, stderr.String())
+}
+
+func (suite *LintTestSuite) TestPrepareWithNamespaceFlag() {
+	defer suite.ctrl.Finish()
+
+	cfg := Config{
+		Namespace: "table-service",
+	}
+
+	l := Lint{
+		Chart: "./wales/top_40",
+	}
+
+	actual := []string{}
+	command = func(path string, args ...string) cmd {
+		actual = args
+		return suite.mockCmd
+	}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	err := l.Prepare(cfg)
+	suite.Require().Nil(err)
+
+	expected := []string{"--namespace", "table-service", "lint", "./wales/top_40"}
+	suite.Equal(expected, actual)
+}

internal/run/uninstall.go

@@ -0,0 +1,55 @@
+package run
+
+import (
+	"fmt"
+)
+
+// Uninstall is an execution step that calls `helm uninstall` when executed.
+type Uninstall struct {
+	Release     string
+	DryRun      bool
+	KeepHistory bool
+	cmd         cmd
+}
+
+// Execute executes the `helm uninstall` command.
+func (u *Uninstall) Execute(_ Config) error {
+	return u.cmd.Run()
+}
+
+// Prepare gets the Uninstall ready to execute.
+func (u *Uninstall) Prepare(cfg Config) error {
+	if u.Release == "" {
+		return fmt.Errorf("release is required")
+	}
+
+	args := make([]string, 0)
+
+	if cfg.Namespace != "" {
+		args = append(args, "--namespace", cfg.Namespace)
+	}
+	if cfg.Debug {
+		args = append(args, "--debug")
+	}
+
+	args = append(args, "uninstall")
+
+	if u.DryRun {
+		args = append(args, "--dry-run")
+	}
+	if u.KeepHistory {
+		args = append(args, "--keep-history")
+	}
+
+	args = append(args, u.Release)
+
+	u.cmd = command(helmBin, args...)
+	u.cmd.Stdout(cfg.Stdout)
+	u.cmd.Stderr(cfg.Stderr)
+
+	if cfg.Debug {
+		fmt.Fprintf(cfg.Stderr, "Generated command: '%s'\n", u.cmd.String())
+	}
+
+	return nil
+}

internal/run/uninstall_test.go

@@ -0,0 +1,149 @@
+package run
+
+import (
+	"fmt"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/suite"
+	"strings"
+	"testing"
+)
+
+type UninstallTestSuite struct {
+	suite.Suite
+	ctrl            *gomock.Controller
+	mockCmd         *Mockcmd
+	actualArgs      []string
+	originalCommand func(string, ...string) cmd
+}
+
+func (suite *UninstallTestSuite) BeforeTest(_, _ string) {
+	suite.ctrl = gomock.NewController(suite.T())
+	suite.mockCmd = NewMockcmd(suite.ctrl)
+
+	suite.originalCommand = command
+	command = func(path string, args ...string) cmd {
+		suite.actualArgs = args
+		return suite.mockCmd
+	}
+}
+
+func (suite *UninstallTestSuite) AfterTest(_, _ string) {
+	command = suite.originalCommand
+}
+
+func TestUninstallTestSuite(t *testing.T) {
+	suite.Run(t, new(UninstallTestSuite))
+}
+
+func (suite *UninstallTestSuite) TestPrepareAndExecute() {
+	defer suite.ctrl.Finish()
+
+	u := Uninstall{
+		Release: "zayde_wølf_king",
+	}
+
+	actual := []string{}
+	command = func(path string, args ...string) cmd {
+		suite.Equal(helmBin, path)
+		actual = args
+
+		return suite.mockCmd
+	}
+
+	suite.mockCmd.EXPECT().
+		Stdout(gomock.Any())
+	suite.mockCmd.EXPECT().
+		Stderr(gomock.Any())
+	suite.mockCmd.EXPECT().
+		Run().
+		Times(1)
+
+	cfg := Config{}
+	suite.NoError(u.Prepare(cfg))
+	expected := []string{"uninstall", "zayde_wølf_king"}
+	suite.Equal(expected, actual)
+
+	u.Execute(cfg)
+}
+
+func (suite *UninstallTestSuite) TestPrepareDryRunFlag() {
+	u := Uninstall{
+		Release: "firefox_ak_wildfire",
+		DryRun:  true,
+	}
+	cfg := Config{}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	suite.NoError(u.Prepare(cfg))
+	expected := []string{"uninstall", "--dry-run", "firefox_ak_wildfire"}
+	suite.Equal(expected, suite.actualArgs)
+}
+
+func (suite *UninstallTestSuite) TestPrepareKeepHistoryFlag() {
+	u := Uninstall{
+		Release:     "perturbator_sentient",
+		KeepHistory: true,
+	}
+	cfg := Config{}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	suite.NoError(u.Prepare(cfg))
+	expected := []string{"uninstall", "--keep-history", "perturbator_sentient"}
+	suite.Equal(expected, suite.actualArgs)
+}
+
+func (suite *UninstallTestSuite) TestPrepareNamespaceFlag() {
+	u := Uninstall{
+		Release: "carly_simon_run_away_with_me",
+	}
+	cfg := Config{
+		Namespace: "emotion",
+	}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	suite.NoError(u.Prepare(cfg))
+	expected := []string{"--namespace", "emotion", "uninstall", "carly_simon_run_away_with_me"}
+	suite.Equal(expected, suite.actualArgs)
+}
+
+func (suite *UninstallTestSuite) TestPrepareDebugFlag() {
+	u := Uninstall{
+		Release: "just_a_band_huff_and_puff",
+	}
+	stderr := strings.Builder{}
+	cfg := Config{
+		Debug:  true,
+		Stderr: &stderr,
+	}
+
+	command = func(path string, args ...string) cmd {
+		suite.mockCmd.EXPECT().
+			String().
+			Return(fmt.Sprintf("%s %s", path, strings.Join(args, " ")))
+
+		return suite.mockCmd
+	}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(&stderr).AnyTimes()
+
+	suite.NoError(u.Prepare(cfg))
+	suite.Equal(fmt.Sprintf("Generated command: '%s --debug "+
+		"uninstall just_a_band_huff_and_puff'\n", helmBin), stderr.String())
+}
+
+func (suite *UninstallTestSuite) TestPrepareRequiresRelease() {
+	// These aren't really expected, but allowing them gives clearer test-failure messages
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	u := Uninstall{}
+	err := u.Prepare(Config{})
+	suite.EqualError(err, "release is required", "Uninstall.Release should be mandatory")
+}

internal/run/upgrade.go

@@ -10,10 +10,16 @@ type Upgrade struct {
 	Release string
 
 	ChartVersion  string
+	DryRun        bool
 	Wait          bool
+	Values        string
+	StringValues  string
+	ValuesFiles   []string
 	ReuseValues   bool
 	Timeout       string
 	Force         bool
+	Atomic        bool
+	CleanupOnFail bool
 
 	cmd cmd
 }
@@ -25,18 +31,59 @@ func (u *Upgrade) Execute(_ Config) error {
 
 // Prepare gets the Upgrade ready to execute.
 func (u *Upgrade) Prepare(cfg Config) error {
-	args := []string{"--kubeconfig", cfg.KubeConfig}
+	if u.Chart == "" {
+		return fmt.Errorf("chart is required")
+	}
+	if u.Release == "" {
+		return fmt.Errorf("release is required")
+	}
+
+	args := make([]string, 0)
 
 	if cfg.Namespace != "" {
 		args = append(args, "--namespace", cfg.Namespace)
 	}
-
-	args = append(args, "upgrade", "--install", u.Release, u.Chart)
-
 	if cfg.Debug {
-		args = append([]string{"--debug"}, args...)
+		args = append(args, "--debug")
 	}
 
+	args = append(args, "upgrade", "--install")
+
+	if u.ChartVersion != "" {
+		args = append(args, "--version", u.ChartVersion)
+	}
+	if u.DryRun {
+		args = append(args, "--dry-run")
+	}
+	if u.Wait {
+		args = append(args, "--wait")
+	}
+	if u.ReuseValues {
+		args = append(args, "--reuse-values")
+	}
+	if u.Timeout != "" {
+		args = append(args, "--timeout", u.Timeout)
+	}
+	if u.Force {
+		args = append(args, "--force")
+	}
+	if u.Atomic {
+		args = append(args, "--atomic")
+	}
+	if u.CleanupOnFail {
+		args = append(args, "--cleanup-on-fail")
+	}
+	if u.Values != "" {
+		args = append(args, "--set", u.Values)
+	}
+	if u.StringValues != "" {
+		args = append(args, "--set-string", u.StringValues)
+	}
+	for _, vFile := range u.ValuesFiles {
+		args = append(args, "--values", vFile)
+	}
+
+	args = append(args, u.Release, u.Chart)
 	u.cmd = command(helmBin, args...)
 	u.cmd.Stdout(cfg.Stdout)
 	u.cmd.Stderr(cfg.Stderr)

internal/run/upgrade_test.go

@@ -31,7 +31,7 @@ func TestUpgradeTestSuite(t *testing.T) {
 	suite.Run(t, new(UpgradeTestSuite))
 }
 
-func (suite *UpgradeTestSuite) TestPrepare() {
+func (suite *UpgradeTestSuite) TestPrepareAndExecute() {
 	defer suite.ctrl.Finish()
 
 	u := Upgrade{
@@ -41,8 +41,7 @@ func (suite *UpgradeTestSuite) TestPrepare() {
 
 	command = func(path string, args ...string) cmd {
 		suite.Equal(helmBin, path)
-		suite.Equal([]string{"--kubeconfig", "/root/.kube/config", "upgrade", "--install",
+		suite.Equal([]string{"upgrade", "--install", "jonas_brothers_only_human", "at40"}, args)
-			"jonas_brothers_only_human", "at40"}, args)
 
 		return suite.mockCmd
 	}
@@ -55,9 +54,7 @@ func (suite *UpgradeTestSuite) TestPrepare() {
 		Run().
 		Times(1)
 
-	cfg := Config{
+	cfg := Config{}
-		KubeConfig: "/root/.kube/config",
-	}
 	err := u.Prepare(cfg)
 	suite.Require().Nil(err)
 	u.Execute(cfg)
@@ -73,26 +70,87 @@ func (suite *UpgradeTestSuite) TestPrepareNamespaceFlag() {
 
 	command = func(path string, args ...string) cmd {
 		suite.Equal(helmBin, path)
-		suite.Equal([]string{"--kubeconfig", "/root/.kube/config", "--namespace", "melt", "upgrade",
+		suite.Equal([]string{"--namespace", "melt", "upgrade", "--install", "shaed_trampoline", "at40"}, args)
-			"--install", "shaed_trampoline", "at40"}, args)
 
 		return suite.mockCmd
 	}
 
-	suite.mockCmd.EXPECT().
+	suite.mockCmd.EXPECT().Stdout(gomock.Any())
-		Stdout(gomock.Any())
+	suite.mockCmd.EXPECT().Stderr(gomock.Any())
-	suite.mockCmd.EXPECT().
-		Stderr(gomock.Any())
-	suite.mockCmd.EXPECT().
-		Run()
 
 	cfg := Config{
 		Namespace: "melt",
-		KubeConfig: "/root/.kube/config",
 	}
 	err := u.Prepare(cfg)
 	suite.Require().Nil(err)
-	u.Execute(cfg)
+}
+
+func (suite *UpgradeTestSuite) TestPrepareWithUpgradeFlags() {
+	defer suite.ctrl.Finish()
+
+	u := Upgrade{
+		Chart:         "hot_ac",
+		Release:       "maroon_5_memories",
+		ChartVersion:  "radio_edit",
+		DryRun:        true,
+		Wait:          true,
+		Values:        "age=35",
+		StringValues:  "height=5ft10in",
+		ValuesFiles:   []string{"/usr/local/stats", "/usr/local/grades"},
+		ReuseValues:   true,
+		Timeout:       "sit_in_the_corner",
+		Force:         true,
+		Atomic:        true,
+		CleanupOnFail: true,
+	}
+
+	cfg := Config{}
+
+	command = func(path string, args ...string) cmd {
+		suite.Equal(helmBin, path)
+		suite.Equal([]string{"upgrade", "--install",
+			"--version", "radio_edit",
+			"--dry-run",
+			"--wait",
+			"--reuse-values",
+			"--timeout", "sit_in_the_corner",
+			"--force",
+			"--atomic",
+			"--cleanup-on-fail",
+			"--set", "age=35",
+			"--set-string", "height=5ft10in",
+			"--values", "/usr/local/stats",
+			"--values", "/usr/local/grades",
+			"maroon_5_memories", "hot_ac"}, args)
+
+		return suite.mockCmd
+	}
+
+	suite.mockCmd.EXPECT().Stdout(gomock.Any())
+	suite.mockCmd.EXPECT().Stderr(gomock.Any())
+
+	err := u.Prepare(cfg)
+	suite.Require().Nil(err)
+}
+
+func (suite *UpgradeTestSuite) TestRequiresChartAndRelease() {
+	// These aren't really expected, but allowing them gives clearer test-failure messages
+	suite.mockCmd.EXPECT().Stdout(gomock.Any()).AnyTimes()
+	suite.mockCmd.EXPECT().Stderr(gomock.Any()).AnyTimes()
+
+	u := Upgrade{
+		Release: "seth_everman_unskippable_cutscene",
+	}
+
+	err := u.Prepare(Config{})
+	suite.EqualError(err, "chart is required", "Chart should be mandatory")
+
+	u = Upgrade{
+		Chart: "billboard_top_zero",
+	}
+
+	err = u.Prepare(Config{})
+	suite.EqualError(err, "release is required", "Release should be mandatory")
 }
 
 func (suite *UpgradeTestSuite) TestPrepareDebugFlag() {
@@ -105,7 +163,6 @@ func (suite *UpgradeTestSuite) TestPrepareDebugFlag() {
 	stderr := strings.Builder{}
 	cfg := Config{
 		Debug:  true,
-		KubeConfig: "/root/.kube/config",
 		Stdout: &stdout,
 		Stderr: &stderr,
 	}
@@ -125,7 +182,7 @@ func (suite *UpgradeTestSuite) TestPrepareDebugFlag() {
 
 	u.Prepare(cfg)
 
-	want := fmt.Sprintf("Generated command: '%s --debug --kubeconfig /root/.kube/config upgrade "+
+	want := fmt.Sprintf("Generated command: '%s --debug upgrade "+
 		"--install lewis_capaldi_someone_you_loved at40'\n", helmBin)
 	suite.Equal(want, stderr.String())
 	suite.Equal("", stdout.String())