brew/Library/Homebrew/cask/test/cask/dsl_test.rb

require "test_helper"

describe Hbc::DSL do
  it "lets you set url, homepage, and version" do
    test_cask = Hbc.load("basic-cask")
    test_cask.url.to_s.must_equal "http://example.com/TestCask.dmg"
    test_cask.homepage.must_equal "http://example.com/"
    test_cask.version.to_s.must_equal "1.2.3"
  end

  describe "when a Cask includes an unknown method" do
    attempt_unknown_method = nil

    before do
      attempt_unknown_method = lambda do
        Hbc::Cask.new("unexpected-method-cask") do
          future_feature :not_yet_on_your_machine
        end
      end
    end

    it "prints a warning that it has encountered an unexpected method" do
      expected = Regexp.compile(<<-EOS.undent.lines.map(&:chomp).join(""))
        (?m)
        Warning:
        .*
        Unexpected method 'future_feature' called on Cask unexpected-method-cask\\.
        .*
        https://github.com/caskroom/homebrew-cask/blob/master/doc/reporting_bugs/pre_bug_report.md
        .*
        https://github.com/caskroom/homebrew-cask#reporting-bugs
      EOS

      attempt_unknown_method.must_output nil, expected
    end

    it "will simply warn, not throw an exception" do
      begin
        shutup do
          attempt_unknown_method.call
        end
      rescue StandardError => e
        flunk("Wanted unexpected method to simply warn, but got exception #{e}")
      end
    end
  end

  describe "header line" do
    it "requires a valid header format" do
      lambda {
        Hbc.load("invalid/invalid-header-format")
      }.must_raise(SyntaxError)
    end

    it "requires the header token to match the file name" do
      err = lambda {
        Hbc.load("invalid/invalid-header-token-mismatch")
      }.must_raise(Hbc::CaskTokenDoesNotMatchError)
      err.message.must_include "Bad header line:"
      err.message.must_include "does not match file name"
    end

    it "does not require a DSL version in the header" do
      test_cask = Hbc.load("no-dsl-version")
      test_cask.token.must_equal "no-dsl-version"
      test_cask.url.to_s.must_equal "http://example.com/TestCask.dmg"
      test_cask.homepage.must_equal "http://example.com/"
      test_cask.version.to_s.must_equal "1.2.3"
    end

    it "may use deprecated DSL version hash syntax" do
      with_environment "HOMEBREW_DEVELOPER" => nil do
        shutup do
          test_cask = Hbc.load("with-dsl-version")
          test_cask.token.must_equal "with-dsl-version"
          test_cask.url.to_s.must_equal "http://example.com/TestCask.dmg"
          test_cask.homepage.must_equal "http://example.com/"
          test_cask.version.to_s.must_equal "1.2.3"
        end
      end
    end
  end

  describe "name stanza" do
    it "lets you set the full name via a name stanza" do
      cask = Hbc::Cask.new("name-cask") do
        name "Proper Name"
      end

      cask.name.must_equal [
        "Proper Name",
      ]
    end

    it "Accepts an array value to the name stanza" do
      cask = Hbc::Cask.new("array-name-cask") do
        name ["Proper Name", "Alternate Name"]
      end

      cask.name.must_equal [
        "Proper Name",
        "Alternate Name",
      ]
    end

    it "Accepts multiple name stanzas" do
      cask = Hbc::Cask.new("multi-name-cask") do
        name "Proper Name"
        name "Alternate Name"
      end

      cask.name.must_equal [
        "Proper Name",
        "Alternate Name",
      ]
    end
  end

  describe "sha256 stanza" do
    it "lets you set checksum via sha256" do
      cask = Hbc::Cask.new("checksum-cask") do
        sha256 "imasha2"
      end

      cask.sha256.must_equal "imasha2"
    end
  end

  describe "language stanza" do
    it "allows multilingual casks" do
      cask = lambda do
        Hbc::Cask.new("cask-with-apps") do
          language "zh" do
            sha256 "abc123"
            "zh-CN"
          end

          language "en-US", default: true do
            sha256 "xyz789"
            "en-US"
          end

          url "https://example.org/#{language}.zip"
        end
      end

      MacOS.stub :languages, ["zh"] do
        cask.call.language.must_equal "zh-CN"
        cask.call.sha256.must_equal "abc123"
        cask.call.url.to_s.must_equal "https://example.org/zh-CN.zip"
      end

      MacOS.stub :languages, ["zh-XX"] do
        cask.call.language.must_equal "zh-CN"
        cask.call.sha256.must_equal "abc123"
        cask.call.url.to_s.must_equal "https://example.org/zh-CN.zip"
      end

      MacOS.stub :languages, ["en"] do
        cask.call.language.must_equal "en-US"
        cask.call.sha256.must_equal "xyz789"
        cask.call.url.to_s.must_equal "https://example.org/en-US.zip"
      end

      MacOS.stub :languages, ["xx-XX"] do
        cask.call.language.must_equal "en-US"
        cask.call.sha256.must_equal "xyz789"
        cask.call.url.to_s.must_equal "https://example.org/en-US.zip"
      end

      MacOS.stub :languages, ["xx-XX", "zh", "en"] do
        cask.call.language.must_equal "zh-CN"
        cask.call.sha256.must_equal "abc123"
        cask.call.url.to_s.must_equal "https://example.org/zh-CN.zip"
      end

      MacOS.stub :languages, ["xx-XX", "en-US", "zh"] do
        cask.call.language.must_equal "en-US"
        cask.call.sha256.must_equal "xyz789"
        cask.call.url.to_s.must_equal "https://example.org/en-US.zip"
      end
    end
  end

  describe "app stanza" do
    it "allows you to specify app stanzas" do
      cask = Hbc::Cask.new("cask-with-apps") do
        app "Foo.app"
        app "Bar.app"
      end

      Array(cask.artifacts[:app]).must_equal [["Foo.app"], ["Bar.app"]]
    end

    it "allow app stanzas to be empty" do
      cask = Hbc::Cask.new("cask-with-no-apps")
      Array(cask.artifacts[:app]).must_equal %w[]
    end
  end

  describe "caveats stanza" do
    it "allows caveats to be specified via a method define" do
      cask = Hbc::Cask.new("plain-cask")

      cask.caveats.must_be :empty?

      cask = Hbc::Cask.new("cask-with-caveats") do
        def caveats; <<-EOS.undent
          When you install this Cask, you probably want to know this.
          EOS
        end
      end

      cask.caveats.must_equal "When you install this Cask, you probably want to know this.\n"
    end
  end

  describe "pkg stanza" do
    it "allows installable pkgs to be specified" do
      cask = Hbc::Cask.new("cask-with-pkgs") do
        pkg "Foo.pkg"
        pkg "Bar.pkg"
      end

      Array(cask.artifacts[:pkg]).must_equal [["Foo.pkg"], ["Bar.pkg"]]
    end
  end

  describe "url stanza" do
    it "prevents defining multiple urls" do
      err = lambda {
        Hbc.load("invalid/invalid-two-url")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'url' stanza may only appear once"
    end
  end

  describe "homepage stanza" do
    it "prevents defining multiple homepages" do
      err = lambda {
        Hbc.load("invalid/invalid-two-homepage")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'homepage' stanza may only appear once"
    end
  end

  describe "version stanza" do
    it "prevents defining multiple versions" do
      err = lambda {
        Hbc.load("invalid/invalid-two-version")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'version' stanza may only appear once"
    end
  end

  describe "appcast stanza" do
    it "allows appcasts to be specified" do
      cask = Hbc.load("with-appcast")
      cask.appcast.to_s.must_match(/^http/)
    end

    it "prevents defining multiple appcasts" do
      err = lambda {
        Hbc.load("invalid/invalid-appcast-multiple")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'appcast' stanza may only appear once"
    end

    it "refuses to load invalid appcast URLs" do
      lambda {
        Hbc.load("invalid/invalid-appcast-url")
      }.must_raise(Hbc::CaskInvalidError)
    end
  end

  describe "gpg stanza" do
    it "allows gpg stanza to be specified" do
      cask = Hbc.load("with-gpg")
      cask.gpg.to_s.must_match(/\S/)
    end

    it "allows gpg stanza to be specified with :key_url" do
      cask = Hbc.load("with-gpg-key-url")
      cask.gpg.to_s.must_match(/\S/)
    end

    it "prevents specifying gpg stanza multiple times" do
      err = lambda {
        Hbc.load("invalid/invalid-gpg-multiple-stanzas")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'gpg' stanza may only appear once"
    end

    it "prevents missing gpg key parameters" do
      err = lambda {
        Hbc.load("invalid/invalid-gpg-missing-key")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'gpg' stanza must include exactly one"
    end

    it "prevents conflicting gpg key parameters" do
      err = lambda {
        Hbc.load("invalid/invalid-gpg-conflicting-keys")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'gpg' stanza must include exactly one"
    end

    it "refuses to load invalid gpg signature URLs" do
      lambda {
        Hbc.load("invalid/invalid-gpg-signature-url")
      }.must_raise(Hbc::CaskInvalidError)
    end

    it "refuses to load invalid gpg key URLs" do
      lambda {
        Hbc.load("invalid/invalid-gpg-key-url")
      }.must_raise(Hbc::CaskInvalidError)
    end

    it "refuses to load invalid gpg key IDs" do
      lambda {
        Hbc.load("invalid/invalid-gpg-key-id")
      }.must_raise(Hbc::CaskInvalidError)
    end

    it "refuses to load if gpg parameter is unknown" do
      lambda {
        Hbc.load("invalid/invalid-gpg-parameter")
      }.must_raise(Hbc::CaskInvalidError)
    end
  end

  describe "depends_on stanza" do
    it "refuses to load with an invalid depends_on key" do
      lambda {
        Hbc.load("invalid/invalid-depends-on-key")
      }.must_raise(Hbc::CaskInvalidError)
    end
  end

  describe "depends_on formula" do
    it "allows depends_on formula to be specified" do
      cask = Hbc.load("with-depends-on-formula")
      cask.depends_on.formula.wont_be_nil
    end

    it "allows multiple depends_on formula to be specified" do
      cask = Hbc.load("with-depends-on-formula-multiple")
      cask.depends_on.formula.wont_be_nil
    end
  end

  describe "depends_on cask" do
    it "allows depends_on cask to be specified" do
      cask = Hbc.load("with-depends-on-cask")
      cask.depends_on.cask.wont_be_nil
    end

    it "allows multiple depends_on cask to be specified" do
      cask = Hbc.load("with-depends-on-cask-multiple")
      cask.depends_on.cask.wont_be_nil
    end
  end

  describe "depends_on macos" do
    it "allows depends_on macos to be specified" do
      cask = Hbc.load("with-depends-on-macos-string")
      cask.depends_on.macos.wont_be_nil
    end
    it "refuses to load with an invalid depends_on macos value" do
      lambda {
        Hbc.load("invalid/invalid-depends-on-macos-bad-release")
      }.must_raise(Hbc::CaskInvalidError)
    end
    it "refuses to load with conflicting depends_on macos forms" do
      lambda {
        Hbc.load("invalid/invalid-depends-on-macos-conflicting-forms")
      }.must_raise(Hbc::CaskInvalidError)
    end
  end

  describe "depends_on arch" do
    it "allows depends_on arch to be specified" do
      cask = Hbc.load("with-depends-on-arch")
      cask.depends_on.arch.wont_be_nil
    end
    it "refuses to load with an invalid depends_on arch value" do
      lambda {
        Hbc.load("invalid/invalid-depends-on-arch-value")
      }.must_raise(Hbc::CaskInvalidError)
    end
  end

  describe "depends_on x11" do
    it "allows depends_on x11 to be specified" do
      cask = Hbc.load("with-depends-on-x11")
      cask.depends_on.x11.wont_be_nil
    end
    it "refuses to load with an invalid depends_on x11 value" do
      lambda {
        Hbc.load("invalid/invalid-depends-on-x11-value")
      }.must_raise(Hbc::CaskInvalidError)
    end
  end

  describe "conflicts_with stanza" do
    it "allows conflicts_with stanza to be specified" do
      cask = Hbc.load("with-conflicts-with")
      cask.conflicts_with.formula.wont_be_nil
    end

    it "refuses to load invalid conflicts_with key" do
      lambda {
        Hbc.load("invalid/invalid-conflicts-with-key")
      }.must_raise(Hbc::CaskInvalidError)
    end
  end

  describe "installer stanza" do
    it "allows installer script to be specified" do
      cask = Hbc.load("with-installer-script")
      cask.artifacts[:installer].first.script[:executable].must_equal "/usr/bin/true"
      cask.artifacts[:installer].first.script[:args].must_equal ["--flag"]
      cask.artifacts[:installer].to_a[1].script[:executable].must_equal "/usr/bin/false"
      cask.artifacts[:installer].to_a[1].script[:args].must_equal ["--flag"]
    end
    it "allows installer manual to be specified" do
      cask = Hbc.load("with-installer-manual")
      cask.artifacts[:installer].first.manual.must_equal "Caffeine.app"
    end
  end

  describe "stage_only stanza" do
    it "allows stage_only stanza to be specified" do
      cask = Hbc.load("stage-only")
      cask.artifacts[:stage_only].first.must_equal [true]
    end

    it "prevents specifying stage_only with other activatables" do
      err = lambda {
        Hbc.load("invalid/invalid-stage-only-conflict")
      }.must_raise(Hbc::CaskInvalidError)
      err.message.must_include "'stage_only' must be the only activatable artifact"
    end
  end

  describe "auto_updates stanza" do
    it "allows auto_updates stanza to be specified" do
      cask = Hbc.load("auto-updates")
      cask.auto_updates.must_equal true
    end
  end

  describe "appdir" do
    it "allows interpolation of the appdir value in stanzas" do
      cask = Hbc.load("appdir-interpolation")
      cask.artifacts[:binary].first.must_equal ["#{Hbc.appdir}/some/path"]
    end

    it "does not include a trailing slash" do
      original_appdir = Hbc.appdir
      Hbc.appdir = "#{original_appdir}/"

      begin
        cask = Hbc::Cask.new("appdir-trailing-slash") do
          binary "#{appdir}/some/path"
        end

        cask.artifacts[:binary].first.must_equal ["#{original_appdir}/some/path"]
      ensure
        Hbc.appdir = original_appdir
      end
    end
  end
end