appship 0.1.0 → 0.2.0

data/test/test_project_config.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "stringio"
+require_relative "../lib/appship"
+
+class ProjectConfigTest < Minitest::Test
+  def setup
+    @directory = Dir.mktmpdir("appship-project-config-")
+    @original_directory = Dir.pwd
+    @original_env_file = ENV["APPSHIP_ENV_FILE"]
+    @original_stdin = $stdin
+    @project_dir = File.join(@directory, "project")
+    FileUtils.mkdir_p(File.join(@project_dir, "Demo.xcodeproj"))
+    Dir.chdir(@project_dir)
+    @local_path = Appship::ProjectConfig.path
+    @global_path = File.join(@directory, "global.config")
+    ENV["APPSHIP_ENV_FILE"] = @global_path
+    $stdin = StringIO.new
+    @profile = {
+      "project_name" => "Demo", "app_name" => "GlobalApp",
+      "pgyer_api_key" => "pgyer-key", "pgyer_password" => "global-password",
+      "fir_api_key" => "fir-key", "fir_password" => "fir-password",
+      "wechat_webhook" => "https://example.test/wechat", "configuration" => "Release"
+    }
+    @global_content = JSON.pretty_generate([@profile, { "project_name" => "Other", "custom" => "keep" }])
+    File.write(@global_path, @global_content)
+  end
+
+  def teardown
+    Dir.chdir(@original_directory)
+    ENV["APPSHIP_ENV_FILE"] = @original_env_file
+    $stdin = @original_stdin
+    FileUtils.remove_entry(@directory)
+  end
+
+  def write_local(data)
+    FileUtils.mkdir_p(File.dirname(@local_path))
+    File.write(@local_path, YAML.dump(data))
+  end
+
+  def resolve(**options)
+    Appship::ProjectConfig.load(@global_path).resolve(interactive: false, **options)
+  end
+
+  def test_partial_project_config_inherits_only_the_matching_global_profile
+    local = { "app_name" => "LocalApp", "configuration" => "Debug" }
+    write_local(local)
+
+    %w[pgyer fir].each do |provider|
+      profile = resolve(provider: provider)
+      assert_equal @profile.merge(local), profile
+      refute profile.key?("custom")
+    end
+    assert_equal local, YAML.safe_load_file(@local_path)
+    assert_equal @global_content, File.read(@global_path)
+  end
+
+  def test_explicit_empty_values_override_global_passwords_and_webhooks
+    local = {
+      "pgyer_api_key" => "local-pgyer-key", "pgyer_password" => "",
+      "fir_api_key" => "local-fir-key", "fir_password" => "",
+      "wechat_webhook" => "", "dingtalk_webhook" => "https://example.test/dingtalk"
+    }
+    write_local(local)
+    profile = resolve
+    options = {}
+    capture_io { Appship::CLI.new.send(:apply_cached_profile!, options, profile) }
+
+    assert_equal "local-pgyer-key", options[:api_key]
+    assert_equal "", options[:password]
+    assert_equal 1, options[:install_type]
+    assert_equal "", options[:wechat_webhook]
+    assert_equal "https://example.test/dingtalk", options[:dingtalk_webhook]
+    assert_equal local, resolve(provider: "fir").slice(*local.keys)
+    assert_equal @global_content, File.read(@global_path)
+  end
+
+  def test_complete_project_config_does_not_create_global_cache
+    write_local(@profile)
+    missing = File.join(@directory, "missing", ".config")
+
+    profile = Appship::ProjectConfig.load(missing).resolve(interactive: false)
+
+    assert_equal @profile, profile
+    refute File.exist?(File.dirname(missing))
+  end
+
+  def test_other_projects_credentials_are_never_used_as_fallback
+    File.write(@global_path, JSON.generate([@profile.merge("project_name" => "Other")]))
+    write_local("app_name" => "LocalApp")
+
+    error = assert_raises(Appship::ConfigurationError) { resolve }
+
+    assert_includes error.message, "缺少 pgyer_api_key"
+    refute_includes File.read(@local_path), "pgyer-key"
+  end
+
+  def test_missing_values_are_prompted_into_local_config_and_can_resume
+    write_local("project_name" => "Demo")
+    missing = File.join(@directory, "missing.config")
+    input = StringIO.new("LocalApp\n")
+    input.define_singleton_method(:tty?) { true }
+    $stdin = input
+
+    capture_io do
+      assert_raises(Appship::ConfigurationError) do
+        Appship::ProjectConfig.load(missing).resolve
+      end
+    end
+    assert_equal "LocalApp", YAML.safe_load_file(@local_path)["app_name"]
+    $stdin = StringIO.new("new-key\n\n")
+    $stdin.define_singleton_method(:tty?) { true }
+    capture_io { Appship::ProjectConfig.load(missing).resolve }
+
+    assert_equal({ "project_name" => "Demo", "app_name" => "LocalApp", "pgyer_api_key" => "new-key", "pgyer_password" => "" }, YAML.safe_load_file(@local_path))
+    refute File.exist?(missing)
+    assert_equal @global_content, File.read(@global_path)
+  end
+
+  def test_credential_overrides_only_persist_locally_and_keep_other_platforms
+    write_local("project_name" => "Demo", "custom" => "keep")
+
+    profile = resolve(credential_overrides: { "pgyer_api_key" => "local-key", "pgyer_password" => "" })
+
+    assert_equal "local-key", profile["pgyer_api_key"]
+    assert_equal "fir-key", profile["fir_api_key"]
+    assert_equal({ "project_name" => "Demo", "custom" => "keep", "pgyer_api_key" => "local-key", "pgyer_password" => "" }, YAML.safe_load_file(@local_path))
+    assert_equal @global_content, File.read(@global_path)
+    assert_equal 0o600, File.stat(@local_path).mode & 0o777
+  end
+
+  def test_setting_a_value_equal_to_global_still_saves_an_explicit_local_override
+    write_local("project_name" => "Demo")
+    cache = Appship::ProjectConfig.load(@global_path)
+    profile = cache.resolve(interactive: false)
+    cache.update_profile!(profile, "pgyer_password" => @profile["pgyer_password"])
+
+    assert_equal @profile["pgyer_password"], YAML.safe_load_file(@local_path)["pgyer_password"]
+    assert_equal @global_content, File.read(@global_path)
+  end
+
+  def test_webhook_command_writes_project_config_without_copying_global_secrets
+    write_local("project_name" => "Demo")
+    capture_io { Appship::CLI.new.start(["webhook", "wechat", ""]) }
+
+    assert_equal({ "project_name" => "Demo", "wechat_webhook" => "" }, YAML.safe_load_file(@local_path))
+    assert_equal @global_content, File.read(@global_path)
+  end
+
+  def test_without_local_config_the_existing_global_cache_is_used
+    cache = Appship::ProjectConfig.load(@global_path)
+    assert_instance_of Appship::Cache, cache
+    profile = cache.resolve(interactive: false)
+    cache.update_profile!(profile, "pgyer_password" => "")
+
+    assert_equal "", JSON.parse(File.read(@global_path)).first["pgyer_password"]
+    refute File.exist?(@local_path)
+  end
+
+  def test_generic_commands_also_receive_merged_build_and_upload_defaults
+    write_local("app_name" => "LocalApp", "pgyer_password" => "", "wechat_webhook" => "")
+    config = Appship::Config.find
+    cli = Appship::CLI.new
+    build = cli.send(:build_options, config)
+    upload = cli.send(:upload_options, config)
+
+    assert_equal @local_path, config.path
+    assert_equal "Demo", build[:scheme]
+    assert_equal "Demo.xcodeproj", build[:project]
+    assert_equal "Release", build[:configuration]
+    assert_equal "pgyer-key", upload[:api_key]
+    assert_equal "LocalApp", upload[:app_name]
+    assert_equal "", upload[:password]
+    assert_equal 1, upload[:install_type]
+    assert_equal "", upload[:wechat_webhook]
+  end
+
+  def test_invalid_project_config_does_not_silently_use_global_config
+    write_local([])
+    assert_raises(Appship::ConfigurationError) { resolve }
+    File.write(@local_path, "{broken")
+    assert_raises(Appship::ConfigurationError) { resolve }
+  end
+
+  def test_duplicate_global_project_names_are_rejected
+    write_local("app_name" => "LocalApp")
+    File.write(@global_path, JSON.generate([@profile, @profile]))
+
+    error = assert_raises(Appship::ConfigurationError) { resolve }
+
+    assert_includes error.message, "project_name 重复"
+  end
+
+  def test_symlinked_project_config_is_rejected_without_changing_target
+    FileUtils.mkdir_p(File.dirname(@local_path))
+    File.symlink(@global_path, @local_path)
+
+    assert_raises(Appship::ConfigurationError) { Appship::ProjectConfig.load(@global_path) }
+    assert_equal @global_content, File.read(@global_path)
+  end
+
+  def test_samples_are_not_loaded_as_active_configuration_or_message
+    Appship::ProjectConfig.init!
+    File.write("#{@local_path}.sample", JSON.generate("app_name" => "MustNotUse"))
+    File.write("#{Appship::Message.path}.sample", "MustNotUse %{name}\n")
+
+    assert_equal "GlobalApp", resolve["app_name"]
+    refute_includes Appship::Message.template, "MustNotUse"
+    refute File.exist?(@local_path)
+    refute File.exist?(Appship::Message.path)
+  end
+
+  def test_init_rejects_symlinked_sample_without_changing_target
+    FileUtils.mkdir_p(File.dirname(@local_path))
+    File.symlink(@global_path, "#{@local_path}.sample")
+
+    assert_raises(Appship::ConfigurationError) { Appship::ProjectConfig.init! }
+    assert_equal @global_content, File.read(@global_path)
+  end
+end

data/test/test_upload_progress.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "stringio"
+require_relative "../lib/appship"
+
+class UploadProgressTest < Minitest::Test
+  class Terminal < StringIO
+    def tty?
+      true
+    end
+  end
+
+  class Connection
+    attr_reader :body
+
+    def initialize(result)
+      @result = result
+    end
+
+    def request(request)
+      @body = request.body_stream
+      if @result.is_a?(Exception)
+        @body.read(1024)
+        raise @result
+      end
+      while @body.read(16 * 1024); end
+      @result
+    end
+  end
+
+  def test_progress_does_not_report_success_until_server_acknowledges
+    [StringIO.new, Terminal.new].each do |output|
+      progress = Appship::UploadProgress.new(100, output: output)
+      progress.start
+      progress.update(100)
+      refute_match(/100%|100 %|上传完成/, output.string)
+
+      progress.finish(success: true)
+      assert_includes output.string, "上传完成"
+      assert_match(/100%/, output.string)
+      completed = output.string.dup
+      progress.finish
+      assert_equal completed, output.string
+    end
+  end
+
+  def test_failed_upload_keeps_actual_byte_count_without_fake_completion
+    output = Terminal.new
+    progress = Appship::UploadProgress.new(100, output: output)
+    progress.start
+    progress.update(25)
+    progress.finish(success: false)
+
+    assert_includes output.string, "上传失败"
+    assert_includes output.string, "25B/100B"
+    refute_match(/100%|上传完成/, output.string)
+  end
+
+  def test_both_platforms_complete_progress_only_on_http_success_and_close_streams
+    Dir.mktmpdir do |directory|
+      file = File.join(directory, "Demo.ipa")
+      File.write(file, "x" * 65_536)
+      [Appship::PgyerUploader, Appship::FirUploader].each do |base|
+        [200, 403, SocketError.new("network failed")].each do |status|
+          result = if status.is_a?(Exception)
+                     status
+                   else
+                     response = Net::HTTPResponse::CODE_TO_OBJ.fetch(status.to_s).new("1.1", status.to_s, "")
+                     response.body = "response"
+                     response.instance_variable_set(:@read, true)
+                     response
+                   end
+          connection = Connection.new(result)
+          klass = Class.new(base) do
+            attr_accessor :connection
+
+            private
+
+            def http(_uri)
+              connection
+            end
+          end
+          uploader = klass.new(api_key: "key", fir_api_token: "token")
+          uploader.connection = connection
+          call = if base == Appship::PgyerUploader
+                   -> { uploader.send(:upload_to_cos!, file, { endpoint: "https://example.test/upload", key: "key", signature: "signature", security_token: "token" }) }
+                 else
+                   -> { uploader.send(:multipart_upload!, "https://example.test/upload", { "key" => "key" }, file) }
+                 end
+          output, = capture_io do
+            if status == 200
+              assert call.call
+            else
+              assert_raises(status.is_a?(Exception) ? SocketError : Appship::UploadError) { call.call }
+            end
+          end
+
+          assert connection.body.instance_variable_get(:@file).closed?
+          if status == 200
+            assert_includes output, "上传完成"
+          else
+            assert_includes output, "上传失败"
+            refute_match(/100%|上传完成/, output)
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_webhook.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "../lib/appship"
+
+class WebhookTest < Minitest::Test
+  class FakeHTTP
+    attr_accessor :use_ssl, :open_timeout, :read_timeout, :write_timeout, :max_retries
+    attr_reader :requests
+
+    def initialize(*responses)
+      @responses = responses
+      @requests = []
+    end
+
+    def request(request)
+      @requests << request
+      response = @responses.shift
+      raise response if response.is_a?(Exception)
+      raise "Unexpected request" unless response
+
+      response
+    end
+  end
+
+  FakeUploader = Struct.new(:result) do
+    def upload!(_file)
+      raise result if result.is_a?(Exception)
+
+      result
+    end
+  end
+
+  def setup
+    @webhook_home = Dir.mktmpdir("appship-webhook-")
+    @original_home = ENV["HOME"]
+    @original_directory = Dir.pwd
+    ENV["HOME"] = @webhook_home
+    Dir.chdir(@webhook_home)
+  end
+
+  def teardown
+    Dir.chdir(@original_directory)
+    ENV["HOME"] = @original_home
+    FileUtils.remove_entry(@webhook_home)
+  end
+
+  def response(body = '{"errcode":0,"errmsg":"ok"}', status: "200")
+    result = Net::HTTPResponse::CODE_TO_OBJ.fetch(status).new("1.1", status, "")
+    result.body = body
+    result.instance_variable_set(:@read, true)
+    result
+  end
+
+  def with_constructor(klass, object)
+    original = klass.method(:new)
+    klass.define_singleton_method(:new) { |*| object }
+    yield
+  ensure
+    klass.define_singleton_method(:new, original)
+  end
+
+  def test_posts_release_message_as_utf8_text_to_both_robots
+    http = FakeHTTP.new(response, response)
+    message = "应用名称: Demo\n更新描述: 完成 100%\n"
+    options = {
+      wechat_webhook: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test-key",
+      dingtalk_webhook: "https://oapi.dingtalk.com/robot/send?access_token=test-token"
+    }
+
+    output, errors = capture_io do
+      with_constructor(Net::HTTP, http) { Appship::Webhook.new(options).notify(message) }
+    end
+
+    assert_equal 2, http.requests.length
+    http.requests.each do |request|
+      assert_equal "POST", request.method
+      assert_equal "application/json; charset=utf-8", request["Content-Type"]
+      assert_equal({ "msgtype" => "text", "text" => { "content" => message } }, JSON.parse(request.body))
+    end
+    assert http.use_ssl
+    assert_equal 0, http.max_retries
+    assert_includes output, "企业微信发布通知已发送"
+    assert_includes output, "钉钉发布通知已发送"
+    assert_empty errors
+    refute_includes output, "test-key"
+    refute_includes output, "test-token"
+  end
+
+  def test_unset_webhooks_do_not_make_requests
+    http = FakeHTTP.new
+    output, errors = capture_io do
+      with_constructor(Net::HTTP, http) do
+        Appship::Webhook.new(wechat_webhook: "", dingtalk_webhook: nil).notify("message")
+      end
+    end
+
+    assert_empty output
+    assert_empty errors
+    assert_empty http.requests
+  end
+
+  def test_failure_notification_contains_context_but_hides_credentials
+    url = "https://example.test/send?key=webhook-token"
+    http = FakeHTTP.new(response)
+    webhook = Appship::Webhook.new(
+      app_name: "Demo", provider: "fir", configuration: "Release",
+      api_key: "api-secret", password: 123456, fir_api_token: "fir-secret",
+      wechat_webhook: url
+    )
+    error = Appship::UploadError.new("failed api-secret 123456 fir-secret #{url} https://upload.test/path?signature=upload-secret")
+    output, errors = capture_io do
+      with_constructor(Net::HTTP, http) { webhook.failure(error) }
+    end
+
+    content = JSON.parse(http.requests.first.body).dig("text", "content")
+    assert_includes content, "发布流程失败"
+    assert_includes content, "应用名称: Demo"
+    assert_includes content, "分发平台: fir.im"
+    assert_includes content, "构建配置: Release"
+    %w[api-secret 123456 fir-secret webhook-token upload-secret].each { |secret| refute_includes content, secret }
+    assert_includes output, "企业微信失败通知已发送"
+    assert_empty errors
+  end
+
+  def test_failure_notification_error_does_not_claim_the_app_was_published
+    http = FakeHTTP.new(SocketError.new("network failed"))
+    output, errors = capture_io do
+      with_constructor(Net::HTTP, http) do
+        Appship::Webhook.new(wechat_webhook: "https://example.test/send").failure(Appship::CommandError.new("archive failed"))
+      end
+    end
+
+    assert_equal 1, http.requests.length
+    assert_empty output
+    assert_includes errors, "失败通知失败"
+    refute_includes errors, "应用已发布"
+  end
+
+  def test_failed_robot_does_not_prevent_other_robot_from_receiving_message
+    http = FakeHTTP.new(response('{"errcode":310000,"errmsg":"keyword missing"}'), response)
+    output, errors = capture_io do
+      with_constructor(Net::HTTP, http) do
+        Appship::Webhook.new(
+          wechat_webhook: "https://example.test/wechat?key=secret",
+          dingtalk_webhook: "https://example.test/dingtalk?access_token=secret"
+        ).notify("发布消息")
+      end
+    end
+
+    assert_equal 2, http.requests.length
+    assert_includes errors, "310000"
+    assert_includes errors, "应用已发布"
+    refute_includes errors, "secret"
+    assert_includes output, "钉钉发布通知已发送"
+  end
+
+  def test_http_parse_and_network_failures_are_warnings
+    [
+      response("secret-body", status: "403"),
+      response("not-json"),
+      response("{}"),
+      Net::ReadTimeout.new
+    ].each do |failure|
+      http = FakeHTTP.new(failure)
+      output, errors = capture_io do
+        with_constructor(Net::HTTP, http) do
+          Appship::Webhook.new(wechat_webhook: "https://example.test/send?key=secret-token").notify("message")
+        end
+      end
+
+      assert_empty output
+      assert_includes errors, "通知失败"
+      refute_includes errors, "secret"
+    end
+  end
+
+  def test_successful_uploads_send_the_exact_rendered_message
+    FileUtils.mkdir_p(File.dirname(Appship::Message.path))
+    File.write(Appship::Message.path, YAML.dump("cli_content" => "发布成功\n应用: %{name}\n下载: %{url}\n"))
+    file = File.join(@webhook_home, "Demo.ipa")
+    File.write(file, "ipa-data")
+    results = [
+      { "data" => { "buildName" => "Demo", "buildKey" => "demo" } },
+      { "provider" => "fir", "data" => { "name" => "Demo" }, "url" => "https://fir.im/demo" }
+    ]
+
+    results.each do |result|
+      [:direct, :after_build].each do |flow|
+        options = { file: file, upload: true, wechat_webhook: "https://example.test/send" }
+        http = FakeHTTP.new(response)
+        output, errors = capture_io do
+          with_constructor(Net::HTTP, http) do
+            with_constructor(Appship::Uploader, FakeUploader.new(result)) do
+              builder = Appship::Builder.new
+              if flow == :direct
+                assert_equal result, builder.upload!(options)
+              else
+                builder.send(:upload_if_requested!, file, options)
+              end
+            end
+          end
+        end
+
+        assert_equal 1, http.requests.length
+        content = JSON.parse(http.requests.first.body).fetch("text").fetch("content")
+        assert_equal content + "✅ 企业微信发布通知已发送\n", output
+        assert_includes content, "应用: Demo"
+        assert_includes content, result["provider"] == "fir" ? "https://fir.im/demo" : "https://www.pgyer.com/demo"
+        assert_empty errors
+      end
+    end
+  end
+
+  def test_successful_upload_uses_each_channel_template_and_approved_format
+    FileUtils.mkdir_p(File.dirname(Appship::Message.path))
+    File.write(Appship::Message.path, <<~YAML)
+      cli_content: |
+        终端: %{name}
+      wechat_webhook_success_content: |
+        **企微: %{name}**
+      wechat_webhook_content: 旧版企微文案
+      wechat_webhook_failure_content: "%{password}"
+      wechat_webhook_format: markdown
+      dingtalk_webhook_content: |
+        钉钉: %{name}
+      feishu_webhook_success_content: |
+        飞书: %{name}
+        下载: %{url}
+      feishu_webhook_format: post
+    YAML
+    file = File.join(@webhook_home, "Demo.ipa")
+    File.write(file, "ipa-data")
+    options = {
+      file: file,
+      wechat_webhook: "https://example.test/wechat",
+      dingtalk_webhook: "https://example.test/dingtalk",
+      feishu_webhook: "https://example.test/feishu",
+      feishu_webhook_secret: "feishu-signing-secret"
+    }
+    result = { "provider" => "fir", "data" => { "name" => "Demo" }, "url" => "https://fir.im/demo" }
+    http = FakeHTTP.new(response, response, response('{"code":0,"msg":"success"}'))
+    output, errors = capture_io do
+      with_constructor(Net::HTTP, http) do
+        with_constructor(Appship::Uploader, FakeUploader.new(result)) { Appship::Builder.new.upload!(options) }
+      end
+    end
+
+    wechat, dingtalk, feishu = http.requests.map { |request| JSON.parse(request.body) }
+    assert_includes output, "终端: Demo\n"
+    refute_includes output, "企微: Demo"
+    refute_includes output, "feishu-signing-secret"
+    assert_empty errors
+    assert_equal({ "msgtype" => "markdown", "markdown" => { "content" => "**企微: Demo**\n" } }, wechat)
+    assert_equal "钉钉: Demo\n", dingtalk.dig("text", "content")
+    assert_equal "post", feishu["msg_type"]
+    paragraphs = feishu.dig("content", "post", "zh_cn", "content")
+    assert_equal({ "tag" => "text", "text" => "飞书: Demo" }, paragraphs.first.first)
+    assert_equal({ "tag" => "a", "text" => "https://fir.im/demo", "href" => "https://fir.im/demo" }, paragraphs.last.last)
+    expected_signature = OpenSSL::HMAC.digest("SHA256", "#{feishu.fetch("timestamp")}\nfeishu-signing-secret", "")
+    assert_equal expected_signature, feishu.fetch("sign").unpack1("m0")
+  end
+
+  def test_custom_failure_messages_use_project_directory_and_keep_redaction
+    project = File.join(@webhook_home, "project")
+    path = Appship::Message.path(project)
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, <<~YAML)
+      cli_content: "成功文案"
+      wechat_webhook_success_content: "企微成功"
+      wechat_webhook_failure_content: |
+        企微失败：%{name} / %{provider} / %{configuration}
+        %{error_type}：%{error_message}
+      wechat_webhook_format: markdown
+      dingtalk_webhook_failure_content: "%{password}"
+      feishu_webhook_failure_content: "飞书失败：%{error_message}"
+      feishu_webhook_format: post
+    YAML
+    options = {
+      project_dir: project, app_name: "Demo", provider: "fir", configuration: "Release",
+      wechat_webhook: "https://example.test/wechat?key=wechat-secret",
+      dingtalk_webhook: "https://example.test/dingtalk",
+      feishu_webhook: "https://open.feishu.cn/open-apis/bot/v2/hook/feishu-token",
+      feishu_webhook_secret: "signing-secret", api_key: "api-secret"
+    }
+    error = Appship::CommandError.new("归档失败 api-secret feishu-token signing-secret https://upload.test/path?token=query-secret")
+    http = FakeHTTP.new(response, response, response('{"code":0}'))
+    _output, warnings = capture_io do
+      with_constructor(Net::HTTP, http) { Appship::Webhook.new(options).failure(error) }
+    end
+
+    wechat, dingtalk, feishu = http.requests.map { |request| JSON.parse(request.body) }
+    assert_equal "text", wechat["msgtype"]
+    assert_equal "text", feishu["msg_type"]
+    assert feishu.key?("sign")
+    assert_includes wechat.dig("text", "content"), "企微失败：Demo / fir.im / Release"
+    assert_includes wechat.dig("text", "content"), "Appship::CommandError"
+    assert_includes dingtalk.dig("text", "content"), "Appship 发布流程失败"
+    assert_includes feishu.dig("content", "text"), "飞书失败：归档失败"
+    assert_includes warnings, "dingtalk_webhook_failure_content 无效"
+    refute_match(/api-secret|feishu-token|signing-secret|query-secret|企微成功/, http.requests.map(&:body).join)
+  end
+
+  def test_invalid_message_yaml_does_not_prevent_builtin_failure_notification
+    path = Appship::Message.path
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, "cli_content: [")
+    http = FakeHTTP.new(response)
+    _output, warnings = capture_io do
+      with_constructor(Net::HTTP, http) do
+        Appship::Webhook.new(wechat_webhook: "https://example.test/send").failure(Appship::CommandError.new("上传失败"))
+      end
+    end
+
+    assert_includes JSON.parse(http.requests.first.body).dig("text", "content"), "上传失败"
+    assert_includes warnings, "无法读取失败消息模板"
+  end
+
+  def test_feishu_uses_text_without_signature_by_default_and_hides_secrets_on_failure
+    url = "https://open.feishu.cn/open-apis/bot/v2/hook/feishu-token"
+    http = FakeHTTP.new(response('{"code":0}'), response('{"code":0}'))
+    capture_io do
+      with_constructor(Net::HTTP, http) do
+        Appship::Webhook.new(feishu_webhook: url).notify("发布成功")
+        Appship::Webhook.new(feishu_webhook: url, feishu_webhook_secret: "signing-secret")
+                        .failure(Appship::CommandError.new("error #{url} feishu-token signing-secret"))
+      end
+    end
+
+    text, failure = http.requests.map { |request| JSON.parse(request.body) }
+    assert_equal({ "msg_type" => "text", "content" => { "text" => "发布成功" } }, text)
+    assert_equal "text", failure["msg_type"]
+    assert failure.key?("sign")
+    assert_includes failure.dig("content", "text"), "发布流程失败"
+    refute_match(/feishu-token|signing-secret/, failure.dig("content", "text"))
+  end
+
+  def test_upload_failure_never_sends_success_notification
+    file = File.join(@webhook_home, "Demo.ipa")
+    File.write(file, "ipa-data")
+    options = { file: file, upload: true, wechat_webhook: "https://example.test/send" }
+
+    http = FakeHTTP.new
+    with_constructor(Net::HTTP, http) do
+      with_constructor(Appship::Uploader, FakeUploader.new(Appship::UploadError.new("upload failed"))) do
+        assert_raises(Appship::UploadError) { Appship::Builder.new.upload!(options) }
+        assert_raises(Appship::UploadError) { Appship::Builder.new.send(:upload_if_requested!, file, options) }
+      end
+    end
+    assert_empty http.requests
+  end
+end