bitrise.yml

format_version: 6
default_step_lib_source: https://github.com/bitrise-io/bitrise-steplib.git

app:
  envs:
  # define these in your .bitrise.secrets.yml
  - BITRISE_CACHE_API_URL: $BITRISE_CACHE_API_URL # use file url scheme (file://) to create a cache archive in a local directory
  - ORIG_BITRISE_SOURCE_DIR: $BITRISE_SOURCE_DIR

workflows:
  test:
    before_run:
    - audit-this-step
    after_run:
    - smoke_test
    - ignore_path_test
    - generic_fs_checks
    - test-stack-version
    # - backward_compatibility_test
    steps:
    - go-list:
    - golint:
    - errcheck:
    - go-test:
    - codecov:
        run_if: .IsCI
        inputs:
        - other_options: -f ${GO_CODE_COVERAGE_REPORT_PATH}
        - CODECOV_TOKEN: "$CODECOV_UPLOAD_TOKEN"

  backward_compatibility_test:
    description: |
      Tests if the cache descriptor file is not changed compared to the previous stable step version.
    envs:
    - TMP_DIR: $ORIG_BITRISE_SOURCE_DIR/_tmp3
    - CACHE_PATH: |
        $BITRISE_CACHE_DIR
        ./_sample_artifacts/filestructure -> ./_sample_artifacts/filestructure/build/findme.test
        ./DoesNotExist/
        ./DoesNotExist
        ~/DoesNotExist
        /Does/not/exists
        ~/.android -> ~/.lockfile
        ./_sample_artifacts/ipas
        ./_sample_artifacts/ipas/
        ./_sample_artifacts/filestructure/build/test.bin
    - IGNORE_PATH: |-
        ./_sample_artifacts/filestructure/sub-dir
        ~/DoesNotExists/This
        !~/.android/dir
        *.apk
        !./_sample_artifacts/filestructure/*.txt
    steps:
    - script:
        title: Cleanup $TMP_DIR and archive tmp files
        inputs:
        - content: rm -rf "$TMP_DIR" "/tmp/cache-archive.tar" "/tmp/cache-info.json"
    - change-workdir:
        title: Switch working dir to $TMP_DIR
        inputs:
        - path: $TMP_DIR
        - is_create_path: true
    - script:
        title: Download assets
        inputs:
        - content: git clone https://github.com/bitrise-samples/sample-artifacts.git $TMP_DIR/_sample_artifacts
    - cache-push:
        title: Latest released version
        run_if: true
        is_skippable: false
        inputs:
        - is_debug_mode: true
        - cache_paths: $CACHE_PATH
        - ignore_check_on_paths: $IGNORE_PATH
    - script:
        title: Extract cache and save the cache descriptor
        is_always_run: true
        inputs:
        - content: |-
            #!/bin/bash
            set -ex

            # extract the archive to get the current stable step version's cache descriptor file
            tar -xPf /tmp/cache-archive.tar
            mv "/tmp/cache-info.json" "/tmp/cache-info_orig.json"

            # restore the workdir for the in-progress step version
            rm -rf $TMP_DIR/*
            git clone https://github.com/bitrise-samples/sample-artifacts.git $TMP_DIR/_sample_artifacts
    - path::./:
        title: in-progress version
        run_if: true
        is_skippable: false
        inputs:
        - is_debug_mode: true
        - cache_paths: $CACHE_PATH
        - ignore_check_on_paths: $IGNORE_PATH
    - script:
        title: Compare cache descriptors
        run_if: true
        inputs:
        - content: |-
            #!/bin/bash
            set -ex

            # extract the archive to get the in-progress version's cache descriptor file
            tar -xPf /tmp/cache-archive.tar

            # check if the current stable step version's cache descriptor file is identical to the
            # in-progress step version's cache descriptor file
            if [ "$(cat /tmp/cache-info_orig.json)" != "$(cat /tmp/cache-info.json)" ] ; then
                echo "Cache descriptor file changed"

                cp "/tmp/cache-info.json" "$BITRISE_DEPLOY_DIR/cache-info.json"
                cp "/tmp/cache-info_orig.json" "$BITRISE_DEPLOY_DIR/cache-info_orig.json"

                exit 1
            fi

  smoke_test:
    description: |
      Simple test to make sure the step is able to cache files
      using some exclude and include paths.
    envs:
    - TMP_DIR: $ORIG_BITRISE_SOURCE_DIR/_tmp1
    steps:
    - script:
        title: Cleanup $TMP_DIR and archive tmp files
        inputs:
        - content: rm -rf "$TMP_DIR" "/tmp/cache-archive.tar" "/tmp/cache-info.json"
    - change-workdir:
        title: Switch working dir to $TMP_DIR
        inputs:
        - path: $TMP_DIR
        - is_create_path: true
    - script:
        title: Download assets
        inputs:
        - content:  git clone https://github.com/bitrise-samples/sample-artifacts.git $TMP_DIR/_sample_artifacts
    - change-workdir:
        title: Switch working dir to $TMP_DIR/_workdir
        run_if: true
        inputs:
        - path: $TMP_DIR/_workdir
        - is_create_path: true
    - path::./:
        title: Step Test
        run_if: true
        is_skippable: false
        inputs:
        - is_debug_mode: true
        - cache_paths: |
            $BITRISE_CACHE_DIR
            ../_sample_artifacts/filestructure -> ../_sample_artifacts/filestructure/build/findme.test
            ./DoesNotExist/
            ./DoesNotExist
            ~/DoesNotExist
            /Does/not/exists
            ~/.android -> ~/.lockfile
            ../_sample_artifacts/ipas
            ../_sample_artifacts/ipas/
            ../_sample_artifacts/filestructure/build/test.bin
        - ignore_check_on_paths: |-
            ../_sample_artifacts/filestructure/sub-dir
            ~/DoesNotExists/This
            !~/.android/dir
            *.apk

  ignore_path_test:
    description: |
      Tests if ignored file's change does not triggers new cache creation.
      An ignored file (in the cache archive) should remain as it was originally, 
      even if it gets modified (locally) betweeen two cache push step runs.
    envs:
    - TMP_DIR: $ORIG_BITRISE_SOURCE_DIR/_tmp2
    - CACHE_PATH: |
        $TMP_DIR
    - IGNORE_PATH: |
        $TMP_DIR/test_ignorechanges.txt
        !*.mp3
    steps:
    - script:
        title: Cleanup $TMP_DIR and archive tmp files
        inputs:
        - content: rm -rf "$TMP_DIR" "/tmp/cache-archive.tar" "/tmp/cache-info.json"
    - change-workdir:
        title: Switch working dir to $TMP_DIR
        inputs:
        - path: $TMP_DIR
        - is_create_path: true
    - script:
        title: Create sample files
        is_always_run: true
        inputs:
        - content: |-
            #!/bin/bash
            set -ex

            # should follow changes
            echo "content" > $TMP_DIR/test_file1.txt

            # should not exists
            echo "content" > $TMP_DIR/test_exclude_ext.mp3

            # should exists but ignore changes
            echo "content" > $TMP_DIR/test_ignorechanges.txt
    - path::./:
        title: Step Test
        is_always_run: true
        run_if: true
        is_skippable: false
        inputs:
        - compress_archive: true
        - is_debug_mode: true
        - cache_paths: $CACHE_PATH
        - ignore_check_on_paths: $IGNORE_PATH
    - script:
        title: Store MD5 hash of an ignored file and modify it
        is_always_run: true
        inputs:
        - content: |-
            #!/bin/bash
            set -ex
            
            # remove TMP_DIR to cleanup test_ignorechanges.txt file
            rm -rf $TMP_DIR
            # extract the archive to get the archived test_ignorechanges.txt file
            tar -xPf /tmp/cache-archive.tar

            # export the MD5 hash of test_ignorechanges.txt file
            # this file's content should remain as it is (in the archive) even if it gets modified
            # since this files is in ignore list and no other files changed
            mymd5=`which md5sum` || mymd5=`which md5`
            FILEMD5=`$mymd5 < $TMP_DIR/test_ignorechanges.txt`
            envman add --key MD5PREVIOUSLY --value "${FILEMD5}"

            # following cache should not update the archive even if this file changes
            echo "content" >> $TMP_DIR/test_ignorechanges.txt

            # .mp3 is part of the exclude list, should not exists
            if [ -f $TMP_DIR/test_exclude_ext.mp3 ]; then
              echo "File exists."
              exit 1
            fi
    - path::./:
        title: Step Test
        is_always_run: true
        run_if: true
        is_skippable: false
        inputs:
        - compress_archive: true
        - is_debug_mode: true
        - cache_paths: $CACHE_PATH
        - ignore_check_on_paths: $IGNORE_PATH
    - script:
        title: Check if MD5 matches the previous one
        is_always_run: true
        inputs:
        - content: |-
            #!/bin/bash
            set -ex
            
            # remove TMP_DIR to cleanup test_ignorechanges.txt file
            rm -rf $TMP_DIR
            # extract the archive to get the archived test_ignorechanges.txt file
            tar -xPf /tmp/cache-archive.tar

            # test_ignorechanges.txt was part of the ignore list, so it's change should not present in the archive
            mymd5=`which md5sum` || mymd5=`which md5`
            MD5CURRENT=`$mymd5 < $TMP_DIR/test_ignorechanges.txt`
            if [ "$MD5CURRENT" != "$MD5PREVIOUSLY" ]; then
              echo "MD5 changed."
              exit 1
            fi

            # .mp3 is part of the exclude list, should not exists
            if [ -f $TMP_DIR/test_exclude_ext.mp3 ]; then
              echo "File exists."
              exit 1
            fi

  generic_fs_checks:
    description: |
      Tests if most of the FS file types are supported.
    envs:
    - TMP_DIR: $ORIG_BITRISE_SOURCE_DIR/_tmp_fs_check
    - CACHE_PATH: $TMP_DIR/cache
    - LINKED_FILES: $TMP_DIR/target
    steps:
    - script:
        title: Cleanup $TMP_DIR and archive tmp files
        inputs:
        - content: rm -rf "$TMP_DIR" "/tmp/cache-archive.tar" "/tmp/cache-info.json"
    - change-workdir:
        title: Switch working dir to $CACHE_PATH
        inputs:
        - path: $CACHE_PATH
        - is_create_path: true
    - script:
        title: Create sample files
        is_always_run: true
        inputs:
        - content: |-
            #!/bin/bash
            set -ex

            # file in root
            echo "content" > $CACHE_PATH/test_file1.txt

            # big file in root
            head -c 1073741825 </dev/urandom > $CACHE_PATH/test_big_random_file1.data

            # file in subdir
            mkdir $CACHE_PATH/subdir
            echo "content" > $CACHE_PATH/subdir/test_file.mp3

            # single dir
            mkdir $CACHE_PATH/single_dir

            mkdir $LINKED_FILES
            # symlink to a temp file
            rm -rf $LINKED_FILES/test_cache_file.txt
            echo "content" > $LINKED_FILES/test_cache_file.txt
            ln -s $LINKED_FILES/test_cache_file.txt $CACHE_PATH/mysymlink
            ln $LINKED_FILES/test_cache_file.txt $CACHE_PATH/myhardlink

            # symlink to a non-existent file
            cd $CACHE_PATH
            ln -s nonexistent_target $CACHE_PATH/invalid_symlink

            # symlink to a directory
            ln -s $LINKED_FILES $CACHE_PATH/symlink_dir

    - path::./:
        title: Step Test
        is_always_run: true
        run_if: true
        is_skippable: false
        inputs:
        - compress_archive: true
        - is_debug_mode: true
        - cache_paths: $CACHE_PATH
    - script:
        title: Check if stored structure exists
        is_always_run: true
        inputs:
        - content: |-
            #!/bin/bash
            set -ex
            
            # remove CACHE_PATH to cleanup
            rm -rf $CACHE_PATH
            mkdir $CACHE_PATH
            cd $CACHE_PATH

            # extract the archive
            tar -xPf /tmp/cache-archive.tar

            if [ ! -d $CACHE_PATH/single_dir ]; then
              echo "dir should exist"
              exit 1
            fi

            if [ ! -f $CACHE_PATH/test_file1.txt ]; then
              echo "file should exist"
              exit 1
            fi

            if [ ! -f $CACHE_PATH/test_big_random_file1.data ]; then
              echo "file should exist"
              exit 1
            fi

            if [ ! -f $CACHE_PATH/subdir/test_file.mp3 ]; then
              echo "file should exist"
              exit 1
            fi

            if [ ! -f $CACHE_PATH/mysymlink ]; then
              echo "file should exist"
              exit 1
            fi

            if [ ! -f $CACHE_PATH/myhardlink ]; then
              echo "file should exist"
              exit 1
            fi

            if [ "$(< $CACHE_PATH/myhardlink)" != "$(< $LINKED_FILES/test_cache_file.txt)" ]; then
              echo "file content mismatch"
              exit 1
            fi

            if [ "$($CACHE_PATH/mysymlink)" != "$($LINKED_FILES/test_cache_file.txt)" ]; then
              echo "symlink path mismatch"
              exit 1
            fi

            if [ ! -L $CACHE_PATH/invalid_symlink ]; then
              echo "symlink does not exist"
              exit 1
            fi

            if [ $(cd -P "$CACHE_PATH/symlink_dir" && pwd) != "$LINKED_FILES" ]; then
              echo "symlink directory path mismatch"
              exit 1
            fi

  test-stack-version:
    description: |
      Test that archive_info.json containing stack ID is created.
    envs:
    - TMP_DIR: $ORIG_BITRISE_SOURCE_DIR/_tmp_stack_version
    - CACHE_PATH: |
        $TMP_DIR
    steps:
    - script:
        title: Cleanup $TMP_DIR and archive tmp files
        inputs:
        - content: rm -rf "$TMP_DIR" "/tmp/cache-archive.tar" "/tmp/cache-info.json"
    - change-workdir:
        title: Switch working dir to $TMP_DIR
        inputs:
        - path: $TMP_DIR
        - is_create_path: true
    - script:
        title: Create sample files
        inputs:
        - content: |-
            #!/bin/bash
            set -ex
            # file in root
            echo "content" > $TMP_DIR/test_file1.txt
    - path::./:
        title: Step Test
        is_always_run: true
        run_if: true
        is_skippable: false
        inputs:
        - compress_archive: true
        - is_debug_mode: true
        - cache_paths: $CACHE_PATH
    - script:
        title: Check that archive_info.json exists
        inputs:
        - content: |-
            #!/bin/env bash
            set -ex
            # remove TMP_DIR to cleanup
            rm -rf $TMP_DIR
            # extract the archive
            firstfile="$(tar -b 1024 -tf /tmp/cache-archive.tar | while read item ; do [[ "$item" =~ .* ]] && echo "$item" && break ; done )"
            echo $firstfile
            if [ $firstfile != "/tmp/archive_info.json" ]; then 
              echo "archive_info.json not found as first file in archive"
              exit 1
            fi

  # ----------------------------------------------------------------
  # --- Utility workflows
  dep-update:
    title: Dep update
    description: |
      Used for updating bitrise dependencies with dep
    steps:
    - script:
        title: Dependency update
        inputs:
        - content: |-
            #!/bin/bash
            set -ex
            go get -u -v github.com/golang/dep/cmd/dep
            dep ensure -v
            dep ensure -v -update

  # ----------------------------------------------------------------
  # --- workflows to Share this step into a Step Library
  audit-this-step:
    steps:
    - script:
        inputs:
        - content: |-
            #!/bin/bash
            set -ex
            stepman audit --step-yml ./step.yml