>.
+
+Still, it is important to define development tasks in the `Makefile` because it allows us to automate and integrate them into CI environment.
+
+
+==== Building the Executable.
+
+Run the following command.
+
+[source, bash]
+----
+$ ./build.sh build
+----
+
+==== Showing a Help
+
+To know what other targets are defined and their usages, just do:
+
+[source, bash]
+----
+$ ./build.sh
+----
+
+This gives you explanations of "public" targets in the `Makefile`, which you are supposed to use in daily developments.
+
+=== Coding Conventions
+
+Coding conventions are defined under `.idea/codeStyles` and `.ideaInspectionProfiles`.
+When you want to propose improvements in the style, please open a pull request containing only files under them.
+
+== Copyright and license
+
+All Rights Reserved by Money Forward.
diff --git a/README.md b/README.md
deleted file mode 100644
index 3174868..0000000
--- a/README.md
+++ /dev/null
@@ -1,2 +0,0 @@
-# insdog
-A repository for next generation of automated testing tool and framework.
diff --git a/attributes.adoc b/attributes.adoc
new file mode 100644
index 0000000..8e05518
--- /dev/null
+++ b/attributes.adoc
@@ -0,0 +1 @@
+include::src/site/asciidoc/en/attributes.adoc[]
\ No newline at end of file
diff --git a/bootstrap.sh b/bootstrap.sh
new file mode 100755
index 0000000..9224893
--- /dev/null
+++ b/bootstrap.sh
@@ -0,0 +1,267 @@
+#!/bin/bash -eu
+
+# Component versions to install
+COMPONENT_VERSIONS="$(cat <<'EOF'
+JDK: 21.0.5-oracle
+JAVADOC_JDK: 25.ea.2-open
+MAVEN: 3.9.6
+GOLANG: 1.21.6
+EOF
+)"
+
+function sed() {
+ /usr/bin/sed "${@}"
+}
+
+# A function to ensure macOS default grep is used.
+function grep() {
+ /usr/bin/grep "${@}"
+}
+
+function projectbrew() {
+ "${brewdir}/bin/brew" "${@}"
+}
+
+function version_for() {
+ local _component_name="${1}"
+ echo "${COMPONENT_VERSIONS}" | grep "^${_component_name}" | cut -f 2 -d ':' | sed -E 's/^ +//g'
+}
+
+function jdk_version() {
+ version_for "JDK"
+}
+function javadoc_jdk_version() {
+ version_for "JAVADOC_JDK"
+}
+function maven_version() {
+ version_for "MAVEN"
+}
+function golang_version() {
+ version_for "GOLANG"
+}
+
+# Reads standard streams (stdout and stderr) and assign the content of them to variables specified by the first and
+# second parameters respectively.
+# Note that this function doesn't declare variables specified by the parameters.
+# They need to be defined in the caller side if necessary.
+# Also note that the behavior is undefined, when a variable name which starts with `__read_std_` is specified.
+# 1: A variable name to which stdout from the parameter 3- will be assigned.
+# 2: A variable name to which stderr from the parameter 3- will be assigned.
+# 3-: A command line to be executed by this function.
+function read_std() {
+ local __read_std_stdout_varname __read_std_stderr_varname
+ local __read_std_tmpfile_stderr __read_std_stdout_content __read_std_stderr_content __read_std_exit_code=0
+ __read_std_stdout_varname="$(printf '%q' "${1}")"
+ __read_std_stderr_varname="$(printf '%q' "${2}")"
+ shift; shift
+ __read_std_tmpfile_stderr="$(mktemp)"
+ __read_std_stdout_content="$("${@}" 2> "${__read_std_tmpfile_stderr}")" || {
+ __read_std_exit_code=$?
+ }
+ __read_std_stdout_content="$(printf '%q' "${__read_std_stdout_content}")"
+ __read_std_stderr_content="$(cat "${__read_std_tmpfile_stderr}")"
+ __read_std_stderr_content="$(printf '%q' "${__read_std_stderr_content}")"
+
+ eval "${__read_std_stdout_varname}=${__read_std_stdout_content}"
+ eval "${__read_std_stderr_varname}=${__read_std_stderr_content}"
+
+ rm -f "${__read_std_tmpfile_stderr}"
+ return "${__read_std_exit_code}"
+}
+
+function __bootstrap__perform_checks() {
+ local _installation_reportdir="${1}" _session_name="${2}"
+ local _failed=0
+ local _stdout _stderr _session_dir="${1}/${_session_name}"
+ shift
+ shift
+ mkdir -p "${_session_dir}"
+ for _i in "${@}"; do
+ mkdir -p "${_session_dir}/${_i}"
+ read_std _stdout _stderr "${_i}" || {
+ echo "${_stdout}" > "${_session_dir}/${_i}/stdout"
+ echo "${_stderr}" > "${_session_dir}/${_i}/stderr"
+ echo "FAIL: <${_i}>" >&2
+ _failed=$((_failed + 1))
+ continue
+ }
+ echo "${_stdout}" > "${_session_dir}/${_i}/stdout"
+ echo "${_stderr}" > "${_session_dir}/${_i}/stderr"
+ echo "pass: <${_i}>" >&2
+ done
+ echo "----"
+ echo "FAILED CHECKS: ${_failed}" >&2
+ [[ 0 == "${_failed}" ]] || return 1
+}
+
+function __bootstrap__checkenv() {
+ local _installation_reportdir="${1}"
+ local _checks=()
+ function is_curl_installed() {
+ which curl
+ }
+ _checks+=("is_curl_installed")
+ function is_git_installed() {
+ which git
+ }
+ _checks+=("is_git_installed")
+ function is_ruby_installed() {
+ which ruby
+ }
+ _checks+=("is_ruby_installed")
+ function is_python3_12_installed() {
+ which python3.12
+ }
+ _checks+=("is_python3_12_installed")
+ __bootstrap__perform_checks \
+ "${_installation_reportdir}" \
+ "pre-check" \
+ "${_checks[@]}"
+}
+
+function install_project_homebrew() {
+ local _homebrew_dir="${1}"
+ mkdir -p "${_homebrew_dir}"
+ git init "${_homebrew_dir}"
+ git -C "${_homebrew_dir}" remote add "origin" https://github.com/Homebrew/brew
+ # git checkout -b main -C "${_homebrew_dir}"
+ curl -L https://github.com/Homebrew/brew/tarball/master | tar xz --strip 1 -C "${_homebrew_dir}"
+ # rm -fr "$("${_homebrew_dir}/bin/brew" --repo homebrew/core)"
+
+ git -C "${_homebrew_dir}" add --all .
+ git -C "${_homebrew_dir}" commit -a -m 'DUMMY COMMIT' >& /dev/null
+}
+
+function bootstrap_homebrew() {
+ local _homebrew_dir="${1}"
+ install_project_homebrew "${_homebrew_dir}" | progress "BOOTSTRAP" 2>&1 /dev/null
+}
+
+function install_brew_package() {
+ local _homebrew_dir="${1}" _package="${2}"
+ projectbrew install "${2}" | tee >(progress "${_package}")
+}
+
+function sdk_install() {
+ local _lang="${1}" _ver="${2}"
+ bash -c 'source '"${SDKMAN_DIR}"'/bin/sdkman-init.sh
+ yes | sdk install '"${_lang}"' '"${_ver}"
+}
+
+function progress() {
+ local _item_name="${1}"
+ echo "BEGIN: ${_item_name}" >&2
+ sed -E 's/^(.*)$/ ['"${_item_name}"'] \1/g' >&2
+ echo "END: ${_item_name}" >&2
+}
+
+
+function caveats() {
+ # LIMITATION: Only PATH environment variable mangling will be considered.
+ sed -n '/==> Caveats/,/END/p' | grep 'PATH=' || :
+}
+
+function reset_caveats_rc() {
+ local _fname="${1}"
+ [[ -e "${_fname}" ]] && rm "${_fname}"
+ touch "${_fname}"
+}
+
+function compose_goenv_rc() {
+ local _project_godir="${1}" _go_version="${2}"
+ echo "
+ export GOENV_ROOT=${_project_godir}/env
+ export GOENV_SHELL=bash
+ export GOPATH=${_project_godir}/${_go_version}
+ export GOROOT=${_project_godir}/env/versions/${_go_version}
+
+ export PATH=${_project_godir}/${_go_version}/bin:${PATH}
+ "
+}
+
+function compose_sdk_rc() {
+ local _jdk_name="${1}" _javadoc_jdk_name="${2}"
+ echo "
+ export SDK_JDK_NAME=${_jdk_name}
+ export SDK_JAVADOC_JDK_NAME=${_javadoc_jdk_name}
+ "
+}
+
+function message() {
+ echo "${@}" >&2
+}
+
+function main() {
+ local _projectdir _project_dependencies_dir _project_brewdir _project_rcdir _caveats_file
+ local _project_godir _goenv_file
+ local _project_sdkman_dir
+ _projectdir="$(dirname "${1}")"
+ _projectdir="$(realpath "${_projectdir}")"
+ _project_dependencies_dir="${_projectdir}/.dependencies"
+
+ _project_brewdir="${_project_dependencies_dir}/homebrew"
+
+ _project_rcdir="${_project_dependencies_dir}/rc"
+ _caveats_file="${_project_dependencies_dir}/rc/caveats.rc"
+
+ _goenv_file="${_project_dependencies_dir}/rc/goenv.rc"
+ _project_godir="${_project_dependencies_dir}/go"
+
+ _sdkenv_file="${_project_dependencies_dir}/rc/sdk.rc"
+ _project_sdkman_dir="${_project_dependencies_dir}/sdkman"
+ shift
+
+ local _precheck_reportdir=".dependencies/bootstrap"
+ mkdir -p "${_precheck_reportdir}"
+
+ # Erase all the downloaded files.
+ message "We are erasing the old .dependencies"
+ sudo rm -fr .dependencies
+ # Performs precheck
+ __bootstrap__checkenv "${_precheck_reportdir}"
+
+ mkdir -p "${_project_rcdir}"
+ touch "${_project_rcdir}/.bash_profile" # Ensure the presence of .bash_profile read by env.rc
+ bootstrap_homebrew "${_project_brewdir}"
+ reset_caveats_rc "${_caveats_file}"
+
+ export HOMEBREW_NO_AUTO_UPDATE=0
+ # Disable this behaviour by setting HOMEBREW_NO_INSTALL_CLEANUP.
+ # Hide these hints with HOMEBREW_NO_ENV_HINTS (see `man brew`).
+ export HOMEBREW_NO_INSTALL_CLEANUP=0
+ export HOMEBREW_NO_ENV_HINTS=0
+
+ # shellcheck disable=SC2129
+ install_brew_package "${_project_brewdir}" make | caveats >> "${_caveats_file}"
+ install_brew_package "${_project_brewdir}" gnu-sed | caveats >> "${_caveats_file}"
+ install_brew_package "${_project_brewdir}" findutils | caveats >> "${_caveats_file}"
+ install_brew_package "${_project_brewdir}" act | caveats >> "${_caveats_file}"
+ install_brew_package "${_project_brewdir}" pandoc | caveats >> "${_caveats_file}"
+
+ # golang
+ mkdir -p "${_project_godir}/env"
+ install_brew_package "${_project_brewdir}" goenv > /dev/null
+ compose_goenv_rc "${_project_godir}" "$(golang_version)" > "${_goenv_file}"
+ # shellcheck disable=SC1090
+ source "${_goenv_file}"
+ "${_project_brewdir}/bin/goenv" install -q "$(golang_version)" 2>&1 | progress "goenv:$(golang_version)"
+ "${_project_godir}/env/versions/$(golang_version)/bin/go" install github.com/Songmu/make2help/cmd/make2help@latest 2>&1 | progress "go:make2help"
+
+ # sdkman & Java
+ export HOME="${_project_rcdir}" # To avoid .bashrc / .bash_profile / .zsh_profile being updated
+ export SDKMAN_DIR="${_project_sdkman_dir}"
+ # install sdkman
+ curl -s "https://get.sdkman.io" | /bin/bash 2>&1 | progress "sdkman"
+
+ sdk_install java "$(javadoc_jdk_version)" | progress "sdkman:java for javadoc"
+ sdk_install java "$(jdk_version)" | progress "sdkman:java"
+ sdk_install maven "$(maven_version)" | progress "sdkman:maven"
+
+ compose_sdk_rc "$(jdk_version)" "$(javadoc_jdk_version)" > "${_sdkenv_file}"
+}
+
+projectdir="$(dirname "${BASH_SOURCE[0]}")"
+projectdir="$(realpath "${projectdir}")"
+brewdir="${projectdir}/.dependencies/homebrew"
+
+main "${0}" "$@"
diff --git a/build.sh b/build.sh
new file mode 100755
index 0000000..95a8639
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+source "$(dirname "${BASH_SOURCE[0]}")/env.rc"
+
+make "${@}"
\ No newline at end of file
diff --git a/env.rc b/env.rc
new file mode 100644
index 0000000..8eb3610
--- /dev/null
+++ b/env.rc
@@ -0,0 +1,33 @@
+[[ "${__ENV_RC__:-""}" == yes ]] && return 0
+__ENV_RC__=yes
+
+function message() {
+ echo "${@}" >&2
+}
+
+function abort() {
+ message "${@}"
+ exit 1
+}
+
+function init_for_macos() {
+ basedir="$(dirname "${BASH_SOURCE[0]}")"
+ rcdir="${basedir}/.dependencies/rc"
+ [[ -d "${rcdir}" ]] || abort "Please run 'bootstrap.sh', first!"
+
+ export PATH="${basedir}/.dependencies/homebrew/bin:${PATH}"
+ source "${rcdir}/sdk.rc"
+ source "${rcdir}/goenv.rc"
+ source "${rcdir}/caveats.rc"
+ source "${rcdir}/.bash_profile"
+}
+
+function main() {
+ if [[ "${OSTYPE}" == "darwin"* ]]; then
+ init_for_macos "${@}"
+ else
+ message "${OSTYPE}: no user terminal initialization step is defined for this os type. Going ahead."
+ fi
+}
+
+main "${@}"
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..81adf87
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,762 @@
+
+ 4.0.0
+ jp.co.moneyforward.insdog
+ insdog-all
+ jar
+
+ 0.4.3-SNAPSHOT
+ An action-based testing framework and library
+
+ insdog
+ http://moneyforward.github.io/${project.name}
+
+
+ scm:git:git@github.com/moneyforward/${project.name}.git
+
+ scm:git:git@github.com:moneyforward/${project.name}.git
+
+ http://moneyforward.github.io/${project.name}
+ ${project.name}-${project.version}
+
+
+
+
+ Apache License, Version 2.0
+ http://www.apache.org/licenses/LICENSE-2.0.txt
+ repo
+
+
+
+
+ Money Forward Corporation
+ http://moneyforward.github.io/
+
+
+
+
+ dakusui
+ Hiroshi Ukai
+ dakusui@gmail.com
+
+
+ rinsyan0518
+ Takamitsu Hamajo
+ rinsyan0518@gmail.com
+
+
+ sukezan
+ Kosuke Yamagami | Kay
+ suke.3gs@icloud.com
+
+
+ kwallaschek
+ Kay Wallaschek
+ kayluis.wallaschek@gmail.com
+
+
+ clover
+ clover-zhao
+ cloverzz521@gmail.com
+
+
+
+
+
+ UTF-8
+ github
+ ${project.basedir}/.generated/build/gems
+
+
+ 1.44.0
+ 4.7.6
+ 4.8.174
+ 2.1.3
+ 6.1.5
+ 1.7.36
+ 2.17.2
+ 2.0.3
+ 1.70
+
+ 6.9.0.202403050737-r
+
+
+ 1.2.0
+ 5.10.1
+ 5.10.1
+ 1.10.2
+
+
+ 2.0.0
+ 2.0.0-RC.1
+ 2.5.11
+ 2.0.1
+ 9.2.12.0
+ 0.8.12
+ 3.2.0
+ 3.3.2
+ 3.3.1
+ 3.13.0
+ 3.3.0
+ 3.2.5
+ 3.3.0
+ 3.6.3
+ 4.0.0-M13
+ 3.5.0
+ 3.3.0
+ 3.1.1
+ 3.1.1
+ 3.0.1
+ 3.5.3
+ 3.1.0
+
+ 0.4.0
+ 24.1.1
+ 5.4.0
+
+
+
+
+
+ com.microsoft.playwright
+ playwright
+ ${playwright.version}
+
+
+ org.slf4j
+ slf4j-simple
+
+
+
+
+ com.eatthepath
+ java-otp
+ ${java-otp.version}
+
+
+ info.picocli
+ picocli
+ ${picocli.version}
+
+
+ org.slf4j
+ slf4j-simple
+
+
+
+
+ org.eclipse.jgit
+ org.eclipse.jgit
+ ${org.eclipse.jgit.version}
+
+
+ io.github.classgraph
+ classgraph
+ ${classgraph.version}
+
+
+ org.slf4j
+ slf4j-simple
+
+
+
+
+ com.github.dakusui
+ osynth
+ ${osynth.version}
+
+
+ com.github.dakusui
+ valid8j
+ ${valid8j.version}
+
+
+ com.github.dakusui
+ actionunit
+ ${actionunit.version}
+
+
+ org.slf4j
+ slf4j-simple
+
+
+
+
+ org.opentest4j
+ opentest4j
+ ${opentest4j.version}
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ ${junit-jupiter-engine.version}
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+ ${junit-jupiter-api.version}
+
+
+ org.junit.platform
+ junit-platform-launcher
+ ${junit-platform-launcher.version}
+
+
+ org.junit.jupiter
+ junit-jupiter-params
+ ${junit-jupiter-api.version}
+
+
+
+
+ org.slf4j
+ slf4j-api
+ ${slf4j-api.version}
+
+
+
+ org.apache.logging.log4j
+ log4j-api
+ ${apache-log4j.version}
+
+
+ org.apache.logging.log4j
+ log4j-core
+ ${apache-log4j.version}
+
+
+
+ org.apache.logging.log4j
+ log4j-slf4j-impl
+ ${apache-log4j.version}
+
+
+
+ org.mockito
+ mockito-core
+ ${mockito-core.version}
+ test
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-clean-plugin
+ ${maven-clean-plugin.version}
+
+
+
+ org.apache.maven.plugins
+ maven-resources-plugin
+ ${maven-resources-plugin.version}
+
+
+ org.codehaus.mojo
+ exec-maven-plugin
+ ${exec-maven-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-resources-plugin
+
+
+ copy-resources
+ process-resources
+
+ resources
+
+
+
+
+ src/main/java
+
+ **/*.js
+
+ .
+
+
+ src/site/asciidoc
+
+ **/*.adoc
+
+ ${project.build.directory}/site/
+
+
+ ${project.build.outputDirectory}
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ ${maven-compiler-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-source-plugin
+ ${maven-source-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-surefire-plugin
+ ${maven-surefire-plugin.version}
+
+ -ea ${surefireArgLine} --add-opens java.base/java.lang.invoke=ALL-UNNAMED
+
+
+
+ org.apache.maven.plugins
+ maven-failsafe-plugin
+ ${maven-failsafe-plugin.version}
+
+ -ea ${failsafeArgLine} --add-opens java.base/java.lang.invoke=ALL-UNNAMED
+
+
+
+
+ integration-test
+ verify
+
+
+
+
+
+ org.jacoco
+ jacoco-maven-plugin
+ ${jacoco-maven-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-javadoc-plugin
+ ${maven-javadoc-plugin.version}
+
+
+ attach-javadocs
+ pre-site
+
+ jar
+
+
+
+
+ src/main/javadoc/overview.md
+
+ --add-script=${project.basedir}/src/site/resources/js/mermaid.min.js
+ --add-script=${project.basedir}/src/site/resources/js/mermaid-init.js
+
+
+
+
+ org.apache.maven.plugins
+ maven-site-plugin
+ ${maven-site-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-project-info-reports-plugin
+ ${maven-project-info-reports-plugin.version}
+
+
+
+ org.apache.maven.plugins
+ maven-jar-plugin
+ ${maven-jar-plugin.version}
+
+
+
+ jp.co.moneyforward.autotest
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-shade-plugin
+ ${maven-shade-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-install-plugin
+ ${maven-install-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-deploy-plugin
+ ${maven-deploy-plugin.version}
+
+
+ org.apache.maven.plugins
+ maven-release-plugin
+ ${maven-release-plugin.version}
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+ 21
+ 21
+
+ -Aproject=${project.groupId}/${project.artifactId}
+
+
+
+ info.picocli
+ picocli-codegen
+ ${picocli.version}
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-source-plugin
+
+
+ attach-sources
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-surefire-plugin
+
+
+
+
+ org.apache.maven.plugins
+ maven-failsafe-plugin
+
+
+ org.jacoco
+ jacoco-maven-plugin
+ ${jacoco-maven-plugin.version}
+
+
+
+ pre-unit-tests
+
+ prepare-agent
+
+
+ ${project.build.directory}/jacoco/jacoco-unit-tests.exec
+ surefireArgLine
+
+
+
+
+ pre-integration-test
+
+ prepare-agent-integration
+
+
+ ${project.build.directory}/jacoco/jacoco-integration-tests.exec
+ failsafeArgLine
+
+
+
+
+ merge-results
+ verify
+
+ merge
+
+
+
+
+ ${project.build.directory}/jacoco
+
+ *.exec
+
+
+
+ ${project.build.directory}/jacoco/jacoco-merged.exec
+
+
+
+
+ post-merge-report
+ verify
+
+ report
+
+
+ ${project.build.directory}/jacoco/jacoco-merged.exec
+ ${project.reporting.outputDirectory}/jacoco
+
+ jp/co/moneyforward/autotest/examples/**
+
+
+
+
+
+
+ org.codehaus.mojo
+ exec-maven-plugin
+
+
+ remove diag-*.png files
+ clean
+
+ exec
+
+
+ bash
+
+
+ ${basedir}/src/build_tools/remove-adoc-diags.sh
+
+
+
+
+
+ remove package-info.java files
+ clean
+
+ exec
+
+
+ bash
+
+
+ ${basedir}/src/build_tools/remove-package-info-java.sh
+
+
+
+
+
+ package-info.java generation
+ generate-sources
+
+ exec
+
+
+ bash
+
+
+ ${basedir}/src/build_tools/package-info-md_to_package-info-java.sh
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-javadoc-plugin
+
+
+ attach-javadocs-for-package
+ package
+
+ jar
+
+
+
+
+
+ org.asciidoctor
+ asciidoctor-maven-plugin
+ ${asciidoctor.maven.plugin.version}
+
+
+
+ org.jruby
+ jruby-complete
+ ${jruby.version}
+
+
+
+ org.asciidoctor
+ asciidoctorj
+ ${asciidoctorj.version}
+
+
+ org.asciidoctor
+ asciidoctorj-diagram
+ ${asciidoctorj.diagram.version}
+
+
+
+ src/site/asciidoc/en
+
+ asciidoctor-diagram
+
+
+
+
+
+
+
+
+
+ generate-html-doc
+ site
+
+ process-asciidoc
+
+
+ html5
+ target/site/en
+
+ .
+ left
+ font
+ true
+
+ -
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-site-plugin
+
+
+
+ org.jruby
+ jruby-complete
+ ${jruby.version}
+
+
+ org.asciidoctor
+ asciidoctor-maven-plugin
+ ${asciidoctor.maven.plugin.version}
+
+
+
+
+ true
+ true
+ false
+ en
+ UTF-8
+ UTF-8
+ false
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-release-plugin
+
+ -Dgpg.passphrase=${gpg.passphrase}
+
+
+
+
+
+
+
+
+ org.jacoco
+ jacoco-maven-plugin
+
+
+
+ report
+
+
+
+
+ ${project.build.directory}/jacoco/jacoco-merged.exec
+
+
+
+
+ org.apache.maven.plugins
+ maven-javadoc-plugin
+
+
+
+ javadoc
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-resources-plugin
+
+
+
+
+
+
+ github-mavenpkg
+ https://maven.pkg.github.com/moneyforward/mavenpkg
+
+
+
+
+
+ mac
+
+
+ mac
+
+
+
+
+ unix
+
+
+ unix
+ Linux
+
+
+
+
+ release-sign-artifacts
+
+
+ performRelease
+ true
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-gpg-plugin
+ ${maven-gpg-plugin.version}
+
+ ${gpg.passphrase}
+
+
+
+ sign-artifacts
+ verify
+
+ sign
+
+
+
+
+
+
+
+
+
diff --git a/src/build_tools/convert_links.lua b/src/build_tools/convert_links.lua
new file mode 100644
index 0000000..558b331
--- /dev/null
+++ b/src/build_tools/convert_links.lua
@@ -0,0 +1,6 @@
+function Link(el)
+ if el.target:match("%.md$") then
+ el.target = el.target:gsub("%.md$", ".html")
+ end
+ return el
+end
diff --git a/src/build_tools/lib/mvn-utils.rc b/src/build_tools/lib/mvn-utils.rc
new file mode 100644
index 0000000..58d5090
--- /dev/null
+++ b/src/build_tools/lib/mvn-utils.rc
@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+unset -f MVN_UTILS_TMP_DIR
+readonly MVN_UTILS_TMP_DIR="${TMPDIR:-/tmp}/.mvn-utils"
+
+function mvn_init() {
+ if [[ ! -d "${MVN_UTILS_TMP_DIR}" ]]; then
+ mkdir -p "${MVN_UTILS_TMP_DIR}"
+ fi
+}
+
+function project_name() {
+ xmllint --xpath '/project/name/text()' <(sed -E 's/xmlns=[^ ]+//g' pom.xml)
+}
+
+function _compose_mvn_command_line() {
+ local _artifact="${1}" _basedir="${2}"
+ echo mvn -B -Dstyle.color=never dependency:unpack -Dartifact="${_artifact}" \
+ -Dproject.basedir="${_basedir}" \
+ -DoutputDirectory="${_basedir}/out"
+}
+
+function _exec_mvn() {
+ local _artifact="${1}" _basedir="${2}" _stdout="${3}"
+ local _mvn_commandline
+ _mvn_commandline="$(_compose_mvn_command_line "${_artifact}" "${_basedir}")"
+ bash -c "${_mvn_commandline}" >"${_stdout}" || {
+ local _exit_code="$?"
+ tail --lines=20 "${_stdout}"
+ echo
+ echo "ERROR: Find more detail in '${_stdout}'." >&2
+ return ${_exit_code}
+ }
+}
+
+function mvn-find() {
+ local _artifact="${1}"
+ shift
+ local _basedir _outdir _stdout _mvn_commandline _pwd _exit_code=0
+
+ mvn_init
+ _basedir="./target"
+ _stdout="${_basedir}/stdout"
+ _outdir="${_basedir}/out"
+ _exec_mvn "${_artifact}" "${_basedir}" "${_stdout}" || {
+ local _exit_code="${?}"
+ return "${_exit_code}"
+ }
+ _pwd="$(pwd)"
+ cd "${_outdir}" || return 1
+ find . "${@}" || {
+ echo "ERROR: command line: find . $*" >&2
+ _exit_code="${?}"
+ }
+ cd "${_pwd}" || return 1
+ return "${_exit_code}"
+}
+
+function mvn-unpack() {
+ local _artifact="${1}"
+ local _dir="${2}"
+ shift
+ local _basedir _outdir _stdout _mvn_commandline _pwd _exit_code=0
+
+ mvn_init
+ _basedir="./target"
+ _stdout="${_basedir}/stdout"
+ _exec_mvn "${_artifact}" "${_basedir}" "${_stdout}" || {
+ local _exit_code="${?}"
+ return "${_exit_code}"
+ }
+ _pwd="$(pwd)"
+ cp -r "${_basedir}/out/"* "${_dir}/"
+}
diff --git a/src/build_tools/mangle-javadoc-html-files.sh b/src/build_tools/mangle-javadoc-html-files.sh
new file mode 100755
index 0000000..6cb4bd0
--- /dev/null
+++ b/src/build_tools/mangle-javadoc-html-files.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+set -E -o nounset -o errexit +o posix -o pipefail
+shopt -s inherit_errexit
+
+# This is a script to mangle HTML files generated by JavaDoc (Java 25 EA).
+# The JS file for mermaid downloaded from cds.jsdelivr.net doesn't work as of Dec/2024.
+# Also, the JavaDoc embeds am info string in a source file with a prefix `language-`, which disturbs the mermaid.min.js script.
+# To address this problem, this script does a couple of things.
+# 1. It replaces all the occurrences of `class="language-mermaid"` with `class=mermaid`
+# 2. It replaces all the occurrences of `../ ... ../mermaid.min.js` with the URL from which it was downloaded originally.
+function main() {
+ local _target_dir="${1}"
+ # Taking care of JavaDoc generated HTML
+ find "${_target_dir}" -type f \
+ -name '*.html' \
+ -exec sed -i -E 's/class=\"language-mermaid\"/class=\"mermaid\"/g' {} \;
+ # Taking care of JavaDoc generated HTML
+ find "${_target_dir}" -type f \
+ -name '*.html' \
+ -exec sed -i -E 's!(\.\./)+script-files/mermaid.min.js!https://cdn.jsdelivr.net/npm/mermaid@11.4.1/dist/mermaid.min.js!g' {} \;
+ # Taking care of pandoc generated HTML
+ find "${_target_dir}" -type f \
+ -name '*.html' \
+ -exec sed -i -E 's!!!g' {} \;
+}
+
+main "${@}"
diff --git a/src/build_tools/package-info-md_to_package-info-java.sh b/src/build_tools/package-info-md_to_package-info-java.sh
new file mode 100755
index 0000000..d7e6079
--- /dev/null
+++ b/src/build_tools/package-info-md_to_package-info-java.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -eu
+
+function convert_package_info_md_to_package_info_java() {
+ local _base_dir=$1
+ local _rel_dir=$2
+ local _i
+ local _out="${_base_dir}/${_rel_dir}/package-info.java"
+ rm -f ${_out}
+ touch ${_out}
+ echo "///" >> ${_out}
+ while IFS= read -r _i
+ do
+ echo "/// ${_i}" >> ${_out}
+ done < "${_base_dir}/${_rel_dir}/package-info.md"
+
+ echo "/// " >> ${_out}
+ echo "package ${_rel_dir//\//.};" >> ${_out}
+}
+
+# find src/main/java -name 'package-info.md' -exec echo convert_package_info_md_to_package_info_java src/main/java
+# convert_package_info_md_to_package_info_java /Users/hiroshi.ukai/Documents/scriptiveunit/src/main/java com/github/dakusui/scriptiveunit/utils
+
+base=src/main/java
+for i in $(find ${base} -name 'package-info.md'); do
+ convert_package_info_md_to_package_info_java ${base} $(dirname ${i#${base}/})
+done;
\ No newline at end of file
diff --git a/src/build_tools/remove-adoc-diags.sh b/src/build_tools/remove-adoc-diags.sh
new file mode 100644
index 0000000..da0ccb6
--- /dev/null
+++ b/src/build_tools/remove-adoc-diags.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -eu
+
+rm diag-*.png >& /dev/null || echo "No file to remove. Let's go ahead." >&2
\ No newline at end of file
diff --git a/src/build_tools/remove-package-info-java.sh b/src/build_tools/remove-package-info-java.sh
new file mode 100644
index 0000000..f1ddb89
--- /dev/null
+++ b/src/build_tools/remove-package-info-java.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -eu
+
+find src/main -name 'package-info.java' -exec rm {} \;
\ No newline at end of file
diff --git a/src/build_tools/render-md-into-html.sh b/src/build_tools/render-md-into-html.sh
new file mode 100755
index 0000000..fd1c888
--- /dev/null
+++ b/src/build_tools/render-md-into-html.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+set -E -o nounset -o errexit +o posix -o pipefail
+shopt -s inherit_errexit
+
+main() {
+ local _indir="${1}" _outdir="${2}" _resources_dir="${3}"
+ local _i
+ local _convert_links
+ _convert_links="$(dirname "${0}")/convert_links.lua"
+ for _i in $(find "${_indir}" -type f -name '*.md' -printf "%P\n"); do
+ local _outfile
+ _outfile="${_outdir}/$(echo "${_i}"|sed -E "s/.md$/.html/g")"
+ mkdir -p "$(dirname "${_outdir}/${_i}")"
+ cat "${_resources_dir}/header.html" > "${_outfile}"
+ pandoc --lua-filter="${_convert_links}" --from markdown --to html "${_indir}/${_i}" >> "${_outfile}"
+ cat "${_resources_dir}/footer.html" >> "${_outfile}"
+ done
+}
+main "${@}"
\ No newline at end of file
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/Click.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/Click.java
new file mode 100644
index 0000000..13ae11a
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/Click.java
@@ -0,0 +1,39 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.github.valid8j.pcond.forms.Printables;
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+import java.util.function.Function;
+
+///
+/// An act that models a user behavior, which clicks a specified element.
+///
+///
+///
+///
+public class Click extends ClickBase {
+ ///
+ /// Creates an object of this class.
+ /// @param selector A selector to designate an element to click.
+ ///
+ public Click(String selector) {
+ this(Printables.function("@" + selector, p -> p.locator(selector)));
+ }
+
+ ///
+ /// Creates an objct of this class.
+ ///
+ /// @param locatorFunction A locator for an element to click.
+ ///
+ public Click(Function locatorFunction) {
+ super(locatorFunction);
+ }
+
+ @Override
+ public Page perform(Page page, ExecutionEnvironment executionEnvironment) {
+ this.locatorFunction.apply(page).click();
+ return page;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/ClickBase.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/ClickBase.java
new file mode 100644
index 0000000..3ef5c95
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/ClickBase.java
@@ -0,0 +1,35 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.utils.InternalUtils;
+
+import java.util.function.Function;
+
+///
+/// An abstract base class for clicking acts.
+///
+public abstract class ClickBase implements Act {
+ final Function locatorFunction;
+
+ ///
+ /// Creates an object of this class.
+ ///
+ /// @param locatorFunction A function to locate an element to click.
+ ///
+ protected ClickBase(Function locatorFunction) {
+ this.locatorFunction = locatorFunction;
+ }
+
+ ///
+ /// Returns a name of this object.
+ /// The returned name is printed in action trees.
+ ///
+ /// @return A name of this object.
+ ///
+ @Override
+ public String name() {
+ return InternalUtils.simpleClassNameOf(this.getClass()) + "[" + this.locatorFunction + "]";
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/ClickIfPresent.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/ClickIfPresent.java
new file mode 100644
index 0000000..6c67b93
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/ClickIfPresent.java
@@ -0,0 +1,34 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+import java.util.function.Function;
+
+///
+/// A class that represents an act, where:
+///
+/// * Click a specified element exists in a page if it exists.
+/// * Otherwise, does nothing.
+///
+/// Check for presence is done by `Locator#isVisible`.
+///
+public class ClickIfPresent extends ClickBase {
+ ///
+ /// Creates an object of this class.
+ ///
+ /// @param locatorFunction A function to locate an element to be clicked by this object on `perform` method's call.
+ ///
+ public ClickIfPresent(Function locatorFunction) {
+ super(locatorFunction);
+ }
+
+ @Override
+ public Page perform(Page value, ExecutionEnvironment executionEnvironment) {
+ Locator targetElement = this.locatorFunction.apply(value);
+ if (targetElement.isVisible())
+ targetElement.click();
+ return value;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/CloseBrowser.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/CloseBrowser.java
new file mode 100644
index 0000000..e224585
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/CloseBrowser.java
@@ -0,0 +1,13 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Browser;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+public class CloseBrowser implements Act {
+ @Override
+ public Void perform(Browser value, ExecutionEnvironment executionEnvironment) {
+ value.close();
+ return null;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/CloseWindow.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/CloseWindow.java
new file mode 100644
index 0000000..08f2afa
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/CloseWindow.java
@@ -0,0 +1,13 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Playwright;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+public class CloseWindow implements Act {
+ @Override
+ public Void perform(Playwright value, ExecutionEnvironment executionEnvironment) {
+ value.close();
+ return null;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/LocatorFunctions.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/LocatorFunctions.java
new file mode 100644
index 0000000..301953a
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/LocatorFunctions.java
@@ -0,0 +1,88 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.github.valid8j.pcond.forms.Printables;
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.options.AriaRole;
+
+import java.util.function.Function;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+///
+/// A class that defines function returning utility methods.
+///
+/// Utility methods in this class return a function whose parameter is `Locator`.
+/// Typically, they are used in combination with methods in `PageFunctions`.
+///
+/// For instance,
+///
+/// ```
+/// new Click(locatorBySelector("#js-sidebar-opener").andThen(byText(sideMenuItem)))
+/// ```
+///
+/// This finds an element (locator) found by another function `PageFunctions#locatorBySelector(String)`, and then find an
+/// element whose text is equal to `sideMenuItem`.
+///
+/// Functions returned by methods in this class can be pretty printed on a call of `toString` method call.
+///
+/// @see PageFunctions
+///
+public enum LocatorFunctions {
+ ;
+
+ ///
+ /// A method to compose a function that returns an element at `i` th position in the element (locator) given as a parameter.
+ ///
+ /// @param i An index of an element to be returned.
+ /// @return A function that returns `i` th element in the given locator.
+ ///
+ public static Function nth(int i) {
+ return Printables.function("nth[" + i + "]", l -> l.nth(i));
+ }
+
+ ///
+ /// Returns a function that finds an element whose text matches `text`, under a given `locator`.
+ ///
+ /// The returned function resolves a locator using `Locator#getByText(String)` method.
+ ///
+ /// @param text A string to be matched with the text of a given element.
+ /// @return A function that returns a locator which matches a given `text` under a locator.
+ ///
+ public static Function byText(String text) {
+ requireNonNull(text);
+ return Printables.function("byText[" + text + "]", l -> l.getByText(text));
+ }
+
+
+ ///
+ /// Returns a function that finds an element whose name matches `name`, under a given `locator`.
+ ///
+ /// The returned function resolves a locator using the following approach.
+ ///
+ /// ```java
+ /// (Locator l) -> l.getByRole(AriaRole.LINK,
+ /// new Locator.GetByRoleOptions().setName(name)
+ /// .setExact(!lenient))
+ /// ```
+ ///
+ /// @param name A string to be matched with the text of a given element.
+ /// @param lenient `true` - Make the search lenient / `false` - Make the search strict.
+ /// @return A function that returns a locator which matches a given `text` under a locator.
+ ///
+ public static Function byName(String name, boolean lenient) {
+ requireNonNull(name);
+ return Printables.function("@[name" + (lenient ? "~" : "=") + name + "]",
+ l -> l.getByRole(AriaRole.LINK,
+ new Locator.GetByRoleOptions().setName(name)
+ .setExact(!lenient)));
+ }
+
+ ///
+ /// Returns a function which gives a text content of an element given as an argument.
+ ///
+ /// @return A function which gives a text content of an element given as an argument.
+ ///
+ public static Function textContent() {
+ return Printables.function("textContent", Locator::textContent);
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/Navigate.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/Navigate.java
new file mode 100644
index 0000000..e90894b
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/Navigate.java
@@ -0,0 +1,26 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+public class Navigate implements Act {
+ private final String url;
+
+ public Navigate(String url) {
+ this.url = requireNonNull(url);
+ }
+
+ @Override
+ public Page perform(Page page, ExecutionEnvironment executionEnvironment) {
+ page.navigate(this.url);
+ return page;
+ }
+
+ @Override
+ public String name() {
+ return this.getClass().getSimpleName() + "[" + this.url + "]";
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/PageAct.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/PageAct.java
new file mode 100644
index 0000000..1ef3d88
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/PageAct.java
@@ -0,0 +1,77 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+import java.util.function.BiConsumer;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+///
+/// A general-purpose act.
+/// Convenient starting point for writing **insdog** based tests.
+///
+public abstract class PageAct implements Act {
+ private final String description;
+
+ ///
+ /// Creates a new instance of this class.
+ ///
+ /// It is advised to give a concise and descriptive string to `description` parameter as it is printed the test report.
+ /// The `description` should be concise but informative enough for a reader to reproduce the same action that this `Act` performs.
+ ///
+ /// @param description A string that describes this object.
+ ///
+ protected PageAct(String description) {
+ this.description = requireNonNull(description);
+ }
+
+ ///
+ /// Creates a `PageAct` with a given description and an action
+ ///
+ /// @param description A string to describe created page act.
+ /// @param action An action to be performed.
+ /// @return A page act that performs `action`.
+ ///
+ public static PageAct pageAct(String description, BiConsumer action) {
+ return new PageAct(description) {
+ @Override
+ protected void action(Page page, ExecutionEnvironment executionEnvironment) {
+ action.accept(page, executionEnvironment);
+ }
+ };
+ }
+
+ ///
+ /// Performs an action defined for this class.
+ /// Its execution is delegated to `perform(Page,ExecutionEnvironment)` method.
+ ///
+ /// @param value A page object on which this `act` is performed.
+ /// @param executionEnvironment An execution environment, in which this act is performed.
+ /// @return The `value` itself should be returned, usually.
+ ///
+ @Override
+ public Page perform(Page value, ExecutionEnvironment executionEnvironment) {
+ this.action(value, executionEnvironment);
+ return value;
+ }
+
+ ///
+ /// A method that defines the `act` to be performed by this object.
+ ///
+ /// @param page A page object on which this `act` is performed.
+ /// @param executionEnvironment An execution environment, in which this act is performed.
+ ///
+ protected abstract void action(Page page, ExecutionEnvironment executionEnvironment);
+
+ ///
+ /// Returns a name of this object.
+ ///
+ /// @return A name of this object.
+ ///
+ @Override
+ public String name() {
+ return "Page[" + this.description + "]";
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/PageFunctions.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/PageFunctions.java
new file mode 100644
index 0000000..8c22924
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/PageFunctions.java
@@ -0,0 +1,198 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.github.valid8j.pcond.forms.Printables;
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.Page;
+import com.microsoft.playwright.options.AriaRole;
+
+import java.util.function.Function;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+///
+/// A utility class to handle `Page` object.
+///
+/// Methods in this class return a function whose parameter is a `Page` object of **Playwright**.
+///
+/// It is common to see a situation, where a single method call to a page object cannot determine a single element to be returned.
+/// In such a case, you can use functions provided by `LocatorFunctions` in combination.
+///
+/// ```
+/// new Click(PageFunctions.locatorBySelector("#js-sidebar-opener").andThen(LocatorFunctions.byText(sideMenuItem)))
+/// ```
+///
+/// This is an example to find a locator, which is specified by a text `sideMenuItem` under a locator specified by a selector
+/// string `#js-sidebar-opener`.
+///
+/// In general methods in this class are named in the following manner.
+///
+/// ```
+/// {typeName}By{SelectionMethod}
+/// ```
+///
+/// `typeName` can be, for instance, `locator`, `linkLocator`.
+/// `SelectionMethod` can be `Name`, `Text`, `Label`, `Selector`, etc.
+///
+/// Functions returned by methods in this class can be pretty printed on a call of `toString` method call.
+///
+/// @see LocatorFunctions
+///
+public enum PageFunctions {
+ ;
+
+ ///
+ /// Returns a function that resolves a locator specified by `name` in a given `Page` object.
+ ///
+ /// This is a shorthand method for `linkLocatorByName(name, false)`.
+ ///
+ /// @param name A name of a link.
+ /// @return A function that resolves a locator specified by `name` in a given `Page` object.
+ ///
+ public static Function linkLocatorByName(String name) {
+ return linkLocatorByName(name, false);
+ }
+
+ ///
+ /// Returns a function that resolves a given `name` to a locator of a link whose name matches with it.
+ ///
+ /// @param name A name of a link locator to be matched.
+ /// @param lenient `true` - partial match / `false` - exact match.
+ /// @return A function that resolves a given `name` to a locator of a link whose name matches with it.
+ ///
+ public static Function linkLocatorByName(String name, boolean lenient) {
+ return Printables.function("link[name" + (lenient ? "~" : "=") + name + "]",
+ p -> p.getByRole(AriaRole.LINK, new Page.GetByRoleOptions().setExact(!lenient)
+ .setName(name)));
+ }
+
+ ///
+ /// Returns a function that resolves a locator whose text contains `text` in a given page.
+ ///
+ /// @param text A text to be contained by the matching locator.
+ /// @return a function that resolves a locator whose text contains `text` in a given page.
+ ///
+ public static Function locatorByText(String text) {
+ return locatorByText(text, false);
+ }
+
+ ///
+ /// Returns a function that resolves a locator which matches `text` in a given `Page` object.
+ /// If `lenient` is `true`, a locator whose text contains it is considered matched.
+ /// If `lenient` is `false`, a locator whose text equals to `text` is considered matched.
+ ///
+ /// The match is done by:
+ ///
+ /// ```Page#GetByText(text, new Page.GetByTextOptions().setExact(!lenient)```
+ ///
+ /// @param text A text to be matched.
+ /// @param lenient `true` - lenient / `false` - strict.
+ /// @return A function that resolves a locator which matches `text` in a given `Page` object.
+ ///
+ public static Function locatorByText(String text, boolean lenient) {
+ return Printables.function("@[text" + (lenient ? "~" : "=") + text + "]",
+ p -> p.getByText(text, new Page.GetByTextOptions().setExact(!lenient)));
+ }
+
+ ///
+ /// Returns a function that resolve a locator to a button object in a `Page`, whose name is equal to `name`.
+ ///
+ /// @param name A string to be matched with a locator's name.
+ /// @return A function that resolve a locator to a button object in a `Page`, whose name is equal to `name`.
+ ///
+ public static Function buttonLocatorByName(String name) {
+ return Printables.function("@[name=" + name + "]",
+ p -> p.getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setName(name)
+ .setExact(true)));
+ }
+
+
+ ///
+ /// Returns a function that resolves a locator whose label matches with `label` in a given `Page`.
+ ///
+ /// @param label A string to be matched with a label of a locator.
+ /// @return A function that resolves a locator whose label matches with `label`.
+ ///
+ public static Function locatorByLabel(String label) {
+ return locatorByLabel(label, false);
+ }
+
+ ///
+ /// Returns a function that resolves a locator whose label matches with `label` in a given `Page`.
+ ///
+ /// The resolution is done by a following method-call.
+ ///
+ /// ```java
+ /// Page#getByLabel(label, new Page.GetByLabelOptions().setExact(!lenient))
+ /// ```
+ ///
+ /// If `lenient`is set to `true`, a locator whose label contains `label` will be considered matched.
+ /// If it is `false`, a locator whose label is equal to `label` will be considered matched.
+ ///
+ /// @param label A string to be matched with a label of a locator.
+ /// @param lenient `true` - lenient / `false` - strict.
+ /// @return a function that resolves a locator whose label matches with `label` in a given `Page`.
+ ///
+ public static Function locatorByLabel(String label, boolean lenient) {
+ return Printables.function("@[label" + (lenient ? "~" : "=") + label + "]",
+ p -> p.getByLabel(label, new Page.GetByLabelOptions().setExact(!lenient)));
+ }
+
+
+ ///
+ /// Returns a function that resolves a locator whose placeholder is `placeholder`.
+ ///
+ /// @param placeholder A string to be matched with a locator's placeholder.
+ /// @return A function that resolves a locator whose placeholder is `placeholder`.
+ ///
+ public static Function locatorByPlaceholder(String placeholder) {
+ return Printables.function("@[placeholder=" + placeholder + "]",
+ p -> p.getByPlaceholder(placeholder, new Page.GetByPlaceholderOptions().setExact(true)));
+ }
+
+ ///
+ /// Returns a function that resolves a locator specified by `selector` in a given `Page`.
+ ///
+ /// @param selector A selector string that specifies a locator.
+ /// @return A function that resolves a locator specified by `selector` in a given `Page`.
+ ///
+ public static Function locatorBySelector(String selector) {
+ requireNonNull(selector);
+ return Printables.function("@[" + selector + "]", p -> p.locator(selector));
+ }
+
+ ///
+ /// Returns a function that gives a locator of a link whose text contains a given `text` inside a `Page`.
+ ///
+ /// @param text A string to be matched with a text of a link in a given `Page.
+ /// @return A function that gives a locator of a link whose text matches a given `text` inside a `Page`.
+ ///
+ public static Function linkLocatorByText(String text) {
+ return linkLocatorByText(text, true);
+ }
+
+ ///
+ /// Returns a function that gives a locator of a link whose text equals to a given `text` inside a `Page`.
+ ///
+ /// @param text A string to be matched with a text of a link in a given `Page.
+ /// @return A function that gives a locator of a link whose text equals to a given `text` inside a `Page`.
+ ///
+ public static Function linkLocatorByExactText(String text) {
+ return linkLocatorByText(text, false);
+ }
+
+ ///
+ /// Returns a function that gives a title of the given page.
+ ///
+ /// @return A function that gives a title of the given page.
+ ///
+ public static Function toTitle() {
+ return Printables.function("title", Page::title);
+ }
+
+ public static Function linkLocatorByText(String text, boolean lenient) {
+ return Printables.function("link:@[text" + (lenient ? "~" : "=") + text + "]",
+ p -> p.getByRole(AriaRole.LINK,
+ new Page.GetByRoleOptions().setName(text)
+ .setExact(!lenient)));
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/Screenshot.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/Screenshot.java
new file mode 100644
index 0000000..2874e20
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/Screenshot.java
@@ -0,0 +1,34 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+///
+/// An act that does screenshot.
+/// The browser screenshot is saved under `ExecutionEnvironment#testOutputFilenameFor("screenshot-{stepName}.png")`, where
+/// `{stepName}` is one of `beforeAll`, `beforeEach`, `afterEach`, or `afterAll`.
+///
+/// @see ExecutionEnvironment#testOutputFilenameFor(String)
+///
+public class Screenshot implements Act {
+ ///
+ /// Creates an instance of this class.
+ ///
+ public Screenshot() {
+ // Make default constructor findable.
+ }
+
+ ///
+ /// Performs the screenshot action.
+ ///
+ /// @param value A page for which screenshot is executed.
+ /// @param executionEnvironment An execution environment.
+ /// @return The page object itself given as `value` parameter.
+ ///
+ @Override
+ public Page perform(Page value, ExecutionEnvironment executionEnvironment) {
+ value.screenshot(new Page.ScreenshotOptions().setPath(executionEnvironment.testOutputFilenameFor(String.format("screenshot-%s.png", executionEnvironment.stepName()))));
+ return value;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/SendKey.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/SendKey.java
new file mode 100644
index 0000000..f21e39b
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/SendKey.java
@@ -0,0 +1,82 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.github.valid8j.pcond.forms.Printables;
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+///
+/// A class that represents an action to send key sequence to a specified locator.
+///
+/// If the key sequence starts with `SendKey.MASK_PREFIX`, the part after it will be sent to an element specified by a `locatorFunction` in a given page,
+/// while the part before it (i.e., the `MASK_PREFIX` itselft) will be printed in the log.
+/// This feature is useful for secret strings to be sent to elements, but not to be printed such as passwords.
+///
+///
+public class SendKey implements Act {
+ ///
+ /// A prefix to control a
+ ///
+ public static final String MASK_PREFIX = "MASK!";
+ private final Supplier keySequenceGenerator;
+ private final Function locatorFunction;
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param selector A selector string.
+ /// @param keys Keys to be sent to a locator chosen by a `selector` string.
+ /// @see SendKey#SendKey(Function, String)
+ ///
+ public SendKey(String selector, String keys) {
+ this(Printables.function("@" + selector, (Page p) -> p.locator(selector)), keys);
+ }
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param locatorFunction A function to choose a locator from a given page.
+ /// @param keys Keys to be sent to a chosen locator.
+ ///
+ public SendKey(Function locatorFunction, String keys) {
+ this(locatorFunction, toSupplier(requireNonNull(keys)));
+ }
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param locatorFunction A function to choose a locator from a given page.
+ /// @param keySequenceGenerator A supplier that generates a key sequence to be sent to a chosen locator.
+ ///
+ public SendKey(Function locatorFunction, Supplier keySequenceGenerator) {
+ this.locatorFunction = requireNonNull(locatorFunction);
+ this.keySequenceGenerator = requireNonNull(keySequenceGenerator);
+ }
+
+ @Override
+ public Page perform(Page value, ExecutionEnvironment executionEnvironment) {
+ this.locatorFunction.apply(value).focus();
+ String keys = this.keySequenceGenerator.get();
+ value.keyboard().type(keys.startsWith(MASK_PREFIX) ? keys.substring(MASK_PREFIX.length())
+ : keys);
+ return value;
+ }
+
+ @Override
+ public String name() {
+ String keys = keySequenceGenerator.get();
+ return Act.super.name() + "[" + locatorFunction + "][" +
+ (keys.startsWith(MASK_PREFIX) ? MASK_PREFIX
+ : keys) + "]";
+ }
+
+ private static Supplier toSupplier(String keys) {
+ return () -> keys;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/StoreStorageState.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/StoreStorageState.java
new file mode 100644
index 0000000..053e0ae
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/StoreStorageState.java
@@ -0,0 +1,22 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.BrowserContext;
+import com.microsoft.playwright.Page;
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+import java.nio.file.Paths;
+
+public class StoreStorageState implements Act {
+ private final String filePath;
+
+ public StoreStorageState(String filePath) {
+ this.filePath = filePath;
+ }
+
+ @Override
+ public Page perform(Page page, ExecutionEnvironment executionEnvironment) {
+ page.context().storageState(new BrowserContext.StorageStateOptions().setPath(Paths.get(filePath)));
+ return page;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/TableQuery.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/TableQuery.java
new file mode 100644
index 0000000..6af46e8
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/TableQuery.java
@@ -0,0 +1,206 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import com.microsoft.playwright.Locator;
+import com.microsoft.playwright.Page;
+
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+import static com.github.valid8j.fluent.Expectations.require;
+import static com.github.valid8j.fluent.Expectations.value;
+import static java.util.Arrays.asList;
+import static jp.co.moneyforward.autotest.framework.utils.Valid8JCliches.mapToKeyList;
+
+///
+/// A class to query HTML table object as if it were an SQL relation.
+/// Note that this class is designed to select only one column.
+///
+///
+/// ```java
+/// void example() {
+/// try (Playwright playwright = Playwright.create()) {
+/// BrowserType chromium = playwright.chromium();
+/// try (Browser browser = chromium.launch(new BrowserType.LaunchOptions().setHeadless(false))) {
+/// Page page = browser.newPage();
+/// page.navigate(testTableResourcePath());
+/// //#js-ca-main-contents > table > thead
+///
+/// Locator l = TableQuery.select("事業者・年度の切替")
+/// .from("body > table")
+/// .where(term("事業者名", "abc-154206"))
+/// .normalizeWith(normalizerFunction())
+/// .build()
+/// .perform(page)
+/// .getFirst();
+/// }
+/// ```
+///
+///
+/// **Limitation:**
+///
+/// - The target HTML table must have unique headers (`th`) for all columns.
+/// - Only "equal" condition is supported.
+/// - Only conjunctions are supported.
+///
+/// In case you think these need to be improved, contact the development team of *insdog*.
+///
+/// @param tableName A locator string to specify a table within a `Page` object.
+/// @param columnName A column from which value is project to the result.
+/// @param queryTerms Condition terms to select rows in a table.
+/// @param normalizer A `BinaryOperator` to normalize an incomplete row.
+///
+/// @see TableQuery.Term
+///
+public record TableQuery(String tableName, String columnName, List queryTerms,
+ BiFunction, List, List> normalizer) {
+ ///
+ /// A method from which you can start building a query.
+ /// A `Builder` class object, which holds `columnName` as a column to project to the result will be returned.
+ ///
+ /// @param columnName A column to be projected into the result.
+ /// @return A builder object.
+ ///
+ public static TableQuery.Builder select(String columnName) {
+ Builder builder = new Builder();
+ builder.columnName = columnName;
+ return builder;
+ }
+
+ ///
+ /// Performs the query on the given `page`.
+ ///
+ /// @param page A page object on which this query will be performed.
+ /// @return A list of locators, each of whose enclosing row that satisfies the `terms`.
+ ///
+ public List perform(Page page) {
+ String headerLocatorString = String.format("%s thead tr", this.tableName());
+ Locator headerRow = page.locator(headerLocatorString);
+ headerRow.waitFor();
+ Map columnIndices = composeColumnNameIndices(headerRow.locator("th"));
+
+ require(value(columnIndices).function(mapToKeyList())
+ .asList()
+ .toBe()
+ .containing(columnName()));
+
+ List> matches = new ArrayList<>();
+ Optional> lastCompleteRow = Optional.empty();
+ Locator rowLocator = page.locator(String.format("%s > tbody > tr", tableName()));
+ for (int i = 0; i < rowLocator.count(); i++) {
+ Locator eachRowLocator = rowLocator.nth(i);
+ List columnsInEachRow = toColumns(eachRowLocator);
+ if (isCompleteRow(columnsInEachRow, columnIndices))
+ lastCompleteRow = Optional.of(columnsInEachRow);
+ List eachRow = lastCompleteRow.filter(r -> !isCompleteRow(columnsInEachRow, columnIndices))
+ .map(r -> this.normalizer().apply(r, columnsInEachRow))
+ .orElse(columnsInEachRow);
+
+ boolean matched = true;
+ for (Term eachQueryTerm : queryTerms()) {
+ String filterTargetColumnValue = eachRow.get(columnIndices.get(eachQueryTerm.columnName()))
+ .textContent();
+ if (!filterTargetColumnValue.contains(eachQueryTerm.operand())) {
+ matched = false;
+ break;
+ }
+ }
+ if (matched)
+ matches.add(eachRow);
+ }
+ return matches.stream()
+ .map(c -> c.get(columnIndices.get(columnName)))
+ .toList();
+ }
+
+ private static boolean isCompleteRow(List columnsInEachRow, Map columnIndices) {
+ return columnsInEachRow.size() == columnIndices.size();
+ }
+
+ private static Map composeColumnNameIndices(Locator headerCells) {
+ Map columnIndices = new HashMap<>();
+ for (int i = 0; i < headerCells.count(); i++) {
+ String columnName = headerCells.nth(i).textContent();
+ columnIndices.put(columnName, i);
+ }
+ return columnIndices;
+ }
+
+ private static List toColumns(Locator row) {
+ return row.locator("td").all();
+ }
+
+
+ ///
+ /// A class that represents a term in a condition to select rows.
+ /// When a value of the column designated by the `columnName` is equal to `operand`, the term is satisfied.
+ ///
+ /// @param columnName A name of a column.
+ /// @param operand A value
+ ///
+ public record Term(String columnName, String operand) {
+ public static Term term(String columnName, String operand) {
+ return new Term(columnName, operand);
+ }
+ }
+
+ ///
+ /// A builder class for `TableQuery`.
+ ///
+ public static class Builder {
+ private String tableName;
+ private String columnName;
+ private Term[] conditions;
+ private BinaryOperator> normalizer = (lastFullRow, incompleteRow) -> incompleteRow;
+
+ ///
+ /// A table name on which the query will be performed.
+ ///
+ /// @param tableName A locator string of the table.
+ /// @return This object.
+ ///
+ public Builder from(String tableName) {
+ this.tableName = requireNonNull(tableName);
+ return this;
+ }
+
+ ///
+ /// @param terms Conditions with which querying
+ /// @return This object
+ /// @see TableQuery.Term
+ ///
+ public Builder where(Term... terms) {
+ this.conditions = requireNonNull(terms);
+ return this;
+ }
+
+ ///
+ /// @param normalizer A function that normalizes incomplete row.
+ /// @return This object
+ ///
+ public Builder normalizeWith(BinaryOperator> normalizer) {
+ this.normalizer = requireNonNull(normalizer);
+ return this;
+ }
+
+ ///
+ /// Builds a `TableQuery` object from the current field values held by this object.
+ ///
+ /// @return A `TableQuery` object.
+ ///
+ public TableQuery build() {
+ return new TableQuery(this.tableName, columnName, asList(conditions), this.normalizer);
+ }
+
+ ///
+ /// A shorthand method ob `build()`.
+ ///
+ /// @return A built `TableQuery` object.
+ ///
+ public TableQuery $() {
+ return build();
+ }
+ }
+
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/actions/web/Value.java b/src/main/java/jp/co/moneyforward/autotest/actions/web/Value.java
new file mode 100644
index 0000000..8417645
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/actions/web/Value.java
@@ -0,0 +1,11 @@
+package jp.co.moneyforward.autotest.actions.web;
+
+import jp.co.moneyforward.autotest.framework.action.Act;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+public class Value implements Act {
+ @Override
+ public V perform(V value, ExecutionEnvironment executionEnvironment) {
+ return value;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/Act.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/Act.java
new file mode 100644
index 0000000..e5b819a
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/Act.java
@@ -0,0 +1,155 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.valid8j.pcond.forms.Printables;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+import jp.co.moneyforward.autotest.framework.utils.InternalUtils;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+///
+/// This interface represents the smallest and indivisible unit of action in **insdog** 's programming model.
+///
+public interface Act {
+ ///
+ /// Applies this function the given argument: `value`(`T`) and returns the result (`R`).
+ ///
+ /// @param value An argument value.
+ /// @param executionEnvironment An environment in which this function is executed.
+ /// @return the function result.
+ ///
+ R perform(T value, ExecutionEnvironment executionEnvironment);
+
+ ///
+ /// Returns a name of an instance of this interface.
+ ///
+ /// @return A name of this instance.
+ ///
+ default String name() {
+ return InternalUtils.simpleClassNameOf(this.getClass());
+ }
+
+ static Act create(Function func) {
+ return new Func<>(func);
+ }
+
+ static Act create(String name, Function action) {
+ return create(Printables.function(name, action));
+ }
+
+ ///
+ /// A leaf act, which represents a value assignment behavior.
+ ///
+ /// @param The type of the value to be assigned.
+ ///
+ class Let extends Source implements Act {
+ private final T value;
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param value The value to be assigned to the target variable.
+ ///
+ public Let(T value) {
+ this.value = value;
+ }
+
+ ///
+ /// Returns a value to be assigned to the target variable.
+ ///
+ /// @return A value to be assigned to the target variable.
+ ///
+ @Override
+ protected T value() {
+ return this.value;
+ }
+
+ ///
+ /// A name of this act.
+ ///
+ /// @return A name of this act.
+ ///
+ @Override
+ public String name() {
+ return String.format("let[%s]", this.value());
+ }
+
+ }
+
+ ///
+ /// An act that models a function whose input is `T` and output is `R`
+ ///
+ /// @param Input type
+ /// @param Output type
+ ///
+ class Func implements Act {
+ private final Function main;
+
+ ///
+ /// Creates an object of this class from a given function `func`.
+ ///
+ /// @param func A function from which a new object is created.
+ ///
+ public Func(Function func) {
+ this.main = func;
+ }
+
+ public Func(String name, Function func) {
+ this.main = Printables.function(name, func);
+ }
+
+ @Override
+ public R perform(T value, ExecutionEnvironment executionEnvironment) {
+ return this.main.apply(value);
+ }
+
+ @Override
+ public String name() {
+ return InternalUtils.isToStringOverridden(this.main) ? this.main.toString()
+ : "func";
+ }
+ }
+
+ ///
+ /// A leaf act, which models a "sink".
+ /// A sink is a concept, where value is consumed only.
+ ///
+ /// As the design of leaf act of the **insdog** framework, it needs to return a value on a call of `perform` method,
+ /// it returns `null` instead.
+ ///
+ /// @param A type of value consumed by this sink object.
+ ///
+ class Sink extends Func {
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param sink A consumer that processes a target value in the context
+ ///
+ public Sink(Consumer sink) {
+ this("sink", sink);
+ }
+
+ ///
+ /// Creates an object of this class from a given consumer `sink`.
+ /// The sink is made printable using a string `name`.
+ ///
+ /// @param name A name of a consumer. Used on `toString`.
+ /// @param sink A consumer from which a new object is created.
+ ///
+ public Sink(String name, Consumer sink) {
+ super(Printables.function(name, (T value) -> {
+ sink.accept(value);
+ return null;
+ }));
+ }
+ }
+
+ abstract class Source implements Act {
+ @Override
+ public T perform(Object value, ExecutionEnvironment executionEnvironment) {
+ return this.value();
+ }
+
+ protected abstract T value();
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/ActCall.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/ActCall.java
new file mode 100644
index 0000000..9394036
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/ActCall.java
@@ -0,0 +1,48 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Action;
+import com.github.dakusui.actionunit.core.Context;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+
+///
+/// An act that models a call to a form, such as a function or an assertion.
+///
+/// @param Type input parameter
+///
+public record ActCall(String outputVariableName, Act act, String inputVariableName) implements Call {
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param act An act to be called.
+ /// @param outputVariableName A name of a field for output.
+ /// @param inputVariableName A name of a field for input.
+ /// @see Act
+ ///
+ public ActCall(String outputVariableName, Act act, String inputVariableName) {
+ this.inputVariableName = requireNonNull(inputVariableName);
+ this.outputVariableName = requireNonNull(outputVariableName);
+ this.act = requireNonNull(act);
+ }
+
+ @Override
+ public Action toAction(ActionComposer actionComposer) {
+ return actionComposer.create(this);
+ }
+
+ ///
+ /// Returns an input variable's value for this `ActCall` object.
+ ///
+ /// This method is a shorthand of ```sceneCall.workingVariableStore(context).get(inputVariableName())```.
+ ///
+ /// @param sceneCall An ongoing `sceneCall` to which this `ActCall` object belongs.
+ /// @param context A context, in which the `sceneCall` 's input field value is resolved.
+ /// @return A value of an input field name of a `sceneCall`.
+ /// @see ActCall#resolveVariable(SceneCall, Context)
+ ///
+ @SuppressWarnings("unchecked")
+ T resolveVariable(SceneCall sceneCall, Context context) {
+ return (T) sceneCall.workingVariableStore(context).get(inputVariableName());
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/ActionComposer.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/ActionComposer.java
new file mode 100644
index 0000000..01c8e66
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/ActionComposer.java
@@ -0,0 +1,179 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.actions.Ensured;
+import com.github.dakusui.actionunit.core.Action;
+import com.github.dakusui.actionunit.core.Context;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+import jp.co.moneyforward.autotest.framework.utils.InternalUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static com.github.dakusui.actionunit.core.ActionSupport.*;
+import static com.github.valid8j.classic.Requires.requireNonNull;
+import static jp.co.moneyforward.autotest.framework.utils.InternalUtils.concat;
+
+///
+/// An interface that models a factory of actions.
+///
+/// This interface is designed to be a "visitor" of "calls", each of which represents a call of an action (`ActionFactory`).
+///
+/// A call is a model of an occurrence of an action, and it has input and output.
+///
+/// Calls can be categorized into two.
+/// Calls for scenes (`Scene`) and calls for acts (`Act`).
+/// Corresponding to the subclasses of `Act`, there are subcategories of it, which are `LeafAct`, `AssertionAct`, and `PipelinedAct`.
+///
+/// In this interface, there are `create(XyzCall xyzCall, Map> assignmentResolversFromCurrentCall)` methods defined.
+///
+/// `assignmentResolversFromCurrentCall` is a map from a variable name to a function which resolves its value from the
+/// ongoing context object.
+/// By relying on this object for resolving variable values referenced inside `Act` objects (, which are held by `Calls`), we can define `Act` objects
+/// work in different variable spaces without changing code (transparent to variable space name, which is determined by a call's object name).
+///
+/// @see Call
+/// @see Scene
+/// @see Act
+///
+public interface ActionComposer {
+ ///
+ /// A logger object
+ ///
+ Logger LOGGER = LoggerFactory.getLogger(ActionComposer.class);
+
+ ///
+ /// Returns currently ongoing `SceneCall` object.
+ ///
+ /// @return Currently ongoing `SceneCall` object.
+ ///
+ SceneCall ongoingSceneCall();
+
+ ///
+ /// Returns an execution environment in which actions created by this composer objects are performed.
+ ///
+ /// @return An execution environment.
+ ///
+ ExecutionEnvironment executionEnvironment();
+
+ List ongoingWorkingVariableStoreNames();
+
+ ///
+ /// Creates an action for a given `SceneCall` object.
+ ///
+ /// @param sceneCall A scene call from which an action should be created.
+ /// @return A sequential action created from `sceneCall`.
+ ///
+ default Action create(SceneCall sceneCall) {
+ return sequential(concat(Stream.of(sceneCall.begin(ongoingWorkingVariableStoreNames())),
+ InternalUtils.flattenSequentialAction(sceneCall.targetScene().toSequentialAction(this)),
+ Stream.of(sceneCall.end(ongoingWorkingVariableStoreNames())))
+ .toList());
+ }
+
+ default Action create(EnsuredCall ensuredCall) {
+ Ensured.Builder b = ensure(ensuredCall.targetCall().toAction(this));
+ for (Call each : ensuredCall.ensurers()) {
+ b.with(each.toAction(this));
+ }
+ return b.$();
+ }
+
+ default Action create(RetryCall retryCall) {
+ return retry(retryCall.targetCall().toAction(this))
+ .times(retryCall.times())
+ .on(retryCall.onException())
+ .withIntervalOf(retryCall.interval(), retryCall.intervalUnit())
+ .$();
+ }
+
+ default Action create(AssertionCall call) {
+ return sequential(
+ Stream.concat(
+ Stream.of(call.targetCall().toAction(this)),
+ call.assertionsAsActCalls()
+ .stream()
+ .map(each -> each.toAction(this)))
+ .toList());
+ }
+
+ default Action create(ActCall actCall) {
+ SceneCall ongoingSceneCall = ongoingSceneCall();
+
+ return InternalUtils.action(actCall.act().name() + "[" + actCall.inputVariableName() + "]",
+ toContextConsumerFromAct(ongoingSceneCall,
+ actCall,
+ this.executionEnvironment()));
+ }
+
+ private static Consumer toContextConsumerFromAct(SceneCall ongoingSceneCall,
+ ActCall actCall,
+ ExecutionEnvironment executionEnvironment) {
+ return toContextConsumerFromAct(c -> actCall.resolveVariable(ongoingSceneCall, c),
+ actCall.act(),
+ actCall.outputVariableName(),
+ ongoingSceneCall,
+ executionEnvironment);
+ }
+
+ private static Consumer toContextConsumerFromAct(Function inputVariableResolver,
+ Act act,
+ String outputVariableName,
+ SceneCall ongoingSceneCall,
+ ExecutionEnvironment executionEnvironment) {
+ return c -> {
+ String targetSceneName = ongoingSceneCall.targetScene().name();
+ String actName = act.name();
+ LOGGER.debug("ENTERING: {}:{}", targetSceneName, actName);
+ try {
+ var v = act.perform(inputVariableResolver.apply(c), executionEnvironment);
+ ongoingSceneCall.workingVariableStore(c)
+ .put(outputVariableName, v);
+ } catch (Error | RuntimeException e) {
+ LOGGER.error(e.getMessage());
+ LOGGER.debug(e.getMessage(), e);
+ throw e;
+ } finally {
+ LOGGER.debug("LEAVING: {}:{}", targetSceneName, actName);
+ }
+ };
+ }
+
+ static ActionComposer createActionComposer(final ExecutionEnvironment executionEnvironment) {
+ return new ActionComposer() {
+ final List ongoingWorkingVariableStoreNames = new ArrayList<>();
+
+ SceneCall ongoingSceneCall = null;
+
+ @Override
+ public SceneCall ongoingSceneCall() {
+ return requireNonNull(ongoingSceneCall);
+ }
+
+ @Override
+ public ExecutionEnvironment executionEnvironment() {
+ return executionEnvironment;
+ }
+
+ @Override
+ public Action create(SceneCall sceneCall) {
+ var before = this.ongoingSceneCall;
+ try {
+ this.ongoingSceneCall = sceneCall;
+ return ActionComposer.super.create(sceneCall);
+ } finally {
+ this.ongoingSceneCall = before;
+ }
+ }
+
+ @Override
+ public List ongoingWorkingVariableStoreNames() {
+ return ongoingWorkingVariableStoreNames;
+ }
+ };
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/AssertionCall.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/AssertionCall.java
new file mode 100644
index 0000000..b94cfb2
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/AssertionCall.java
@@ -0,0 +1,75 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Action;
+import com.github.valid8j.fluent.Expectations;
+import com.github.valid8j.pcond.fluent.Statement;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+
+import java.util.List;
+import java.util.function.Function;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+///
+/// A call for assertions.
+///
+/// Both for input and output variable name, this uses `assertion:{target().outputVariableName()}`.
+///
+/// @param Type of value to be validated by assertions.
+///
+public final class AssertionCall extends CallDecorator.Base> {
+ private final List>> assertions;
+
+ ///
+ /// Creates an object of this class.
+ ///
+ /// @param target An act call to be verified by this call.
+ /// @param assertions A list of functions that return verifying statements for the output `target`.
+ ///
+ public AssertionCall(ActCall target, List>> assertions) {
+ super(target);
+ this.assertions = requireNonNull(assertions);
+ }
+
+ ///
+ /// Returns a name of a variable that holds the output of `targetCall()`.
+ ///
+ /// @return A name of a variable that holds the output of `targetCall()`.
+ ///
+ public String outputVariableName() {
+ return this.targetCall().outputVariableName();
+ }
+
+ @Override
+ public Action toAction(ActionComposer actionComposer) {
+ return actionComposer.create(this);
+ }
+
+ ///
+ /// Returns a list of act calls, which are converted from assertions represented as a list of `Function>`.
+ /// Each act call in the list reads the value to be verified from variable specified by `outputVariableName()`.
+ ///
+ /// @return A list of act calls.
+ ///
+ public List> assertionsAsActCalls() {
+ return assertions.stream()
+ .map(assertion -> new ActCall<>(this.outputVariableName(), assertionAsLeafAct(assertion), outputVariableName()))
+ .toList();
+ }
+
+ private Act assertionAsLeafAct(Function> assertion) {
+ return new Act<>() {
+ @Override
+ public R perform(R value, ExecutionEnvironment executionEnvironment) {
+ Expectations.assertStatement(assertion.apply(value));
+ return value;
+ }
+
+ @Override
+ public String name() {
+ // This is a hack to compose a human-readable string.
+ return "assertion:" + assertion.apply(null).statementPredicate();
+ }
+ };
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/AutotestSupport.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/AutotestSupport.java
new file mode 100644
index 0000000..dc2fe2e
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/AutotestSupport.java
@@ -0,0 +1,93 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.valid8j.pcond.fluent.Statement;
+
+import java.util.List;
+import java.util.function.Function;
+
+import static jp.co.moneyforward.autotest.framework.action.ResolverBundle.resolverBundleFor;
+
+///
+/// A facade class of the "autotest" framework.
+///
+public enum AutotestSupport {
+ ;
+
+ ///
+ /// Returns a `Call` object for a given `scene`.
+ ///
+ /// This method internally calls `new SceneCall(Scene, String, ResolverBundle)`.
+ /// A `ResolverBundle` is created from `scene.inputVariableNames()` and `scene.outputVariableNames()`.
+ ///
+ /// @param scene A scene for which a call is created.
+ /// @param variableStoreName A name of a variable store in which the `scene` is performed.
+ /// variables are resolved in the variable store specified by this parameter.
+ /// @return A created `SceneCall` object.
+ /// @see SceneCall
+ ///
+ public static SceneCall sceneToSceneCall(Scene scene, String variableStoreName) {
+ return sceneToSceneCall(scene,
+ variableStoreName,
+ resolverBundleFor(scene, variableStoreName));
+ }
+
+ ///
+ /// Returns a `Call` object for a given `scene`.
+ ///
+ /// A `resolverBundle` is responsible for figuring out values of input and output variables of `scene`.
+ /// The working area is usually specified by `outputVariableStoreName`.
+ /// Note, it is `outputVariableStoreName`.
+ ///
+ /// @param scene A scene for which a call is created
+ /// @param outputVariableStoreName A name of variable store, where the children of `scene` write there output variables.
+ /// @param resolverBundle A resolver bundle which gives values of variables during the execution of the returned scene call.
+ /// @return A `SceneCall` object for `scene`.
+ ///
+ public static SceneCall sceneToSceneCall(Scene scene, String outputVariableStoreName, ResolverBundle resolverBundle) {
+ return new SceneCall(scene, resolverBundle, outputVariableStoreName);
+ }
+
+ ///
+ /// Returns an `Call` object for a given `act`.
+ ///
+ /// @param outputVariableName A name of an output variable, to which `act` writes its output to.
+ /// @param act An `act`, for which a call is created.
+ /// @param inputVariableName A name of variable from which an `act` takes its input.
+ /// @param Input type of `act`.
+ /// @param Output type of `act`.
+ /// @return An `ActCall` object.
+ ///
+ public static ActCall actCall(String outputVariableName, Act act, String inputVariableName) {
+ return new ActCall<>(outputVariableName, act, inputVariableName);
+ }
+
+ ///
+ /// Creates an `AssertionCall` object which executes `act`, then validates it using `assertions`.
+ /// An output from act will be stored in a context with `outputVariableName`.
+ ///
+ /// @param outputVariableName A name of a variable, where an output from `act` is stored.
+ /// @param act An `act` whose output should be validated.
+ /// @param assertions A list of functions each of which creates a `Statement` that validates an output from `act`.
+ /// @param inputVariableName A name of a variable, whose value is given to `act`.
+ /// @param Type of the input to `act`.
+ /// @param Type of the output from `act`.
+ /// @return An `AssertionCall` object.
+ /// @see Act
+ ///
+ public static AssertionCall assertionCall(String outputVariableName, Act act, List>> assertions, String inputVariableName) {
+ return new AssertionCall<>(actCall(outputVariableName, act, inputVariableName), assertions);
+ }
+
+ ///
+ /// Returns a call that retries a given `call`.
+ ///
+ /// @param call A call to be retried on a failure.
+ /// @param times Number of retried to be attempted.
+ /// @param onException An exception class on which `call` should be retried.
+ /// @param interval Interval between tries.
+ /// @return A call that retries a given `call`.
+ ///
+ public static RetryCall retryCall(Call call, int times, Class onException, int interval) {
+ return new RetryCall(call, onException, times, interval);
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/Call.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/Call.java
new file mode 100644
index 0000000..ba6bf28
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/Call.java
@@ -0,0 +1,30 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Action;
+
+///
+/// An interface that models an occurrence of an action in a test scenario.
+///
+/// As a design policy, a call is defined for structural actions of **actionunit**, such as `retry`, `sequential`, `parallel`, etc.
+/// Functionalities exercised in tests are represented as implementations of `LeafAct`.
+///
+/// An instance of a `Call` must be added only once to a `Scene.Builder` at most.
+/// Otherwise,
+///
+/// @see Act
+/// @see Scene
+///
+public sealed interface Call permits ActCall, CallDecorator, SceneCall {
+ ///
+ /// Converts this call to action to an action object.
+ ///
+ /// This is an `Node#accept` method in the **Visitor** pattern.
+ /// Usually implementations of this method should call back by `actionComposer#create(this)` to make a double dispatch happen.
+ ///
+ /// Each value in the `ongoingResolverBundle` is a function that resolves a value of a variable designated by a corresponding key.
+ ///
+ /// @param actionComposer A visitor, which creates an action from this object.
+ /// @return An action created by `actionComposer`.
+ ///
+ Action toAction(ActionComposer actionComposer);
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/CallDecorator.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/CallDecorator.java
new file mode 100644
index 0000000..e19ce0c
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/CallDecorator.java
@@ -0,0 +1,40 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+///
+/// An interface to decorate a behavior of a given call.
+///
+/// @param Type of call object whose behavior is to be modified by an implementation of this interface.
+///
+public sealed interface CallDecorator extends Call permits CallDecorator.Base {
+ ///
+ /// An instance of a call whose behavior is to be decorated by this object.
+ ///
+ /// @return An instance of a call,
+ ///
+ C targetCall();
+
+ ///
+ /// A base class for `CallDecorator`.
+ ///
+ /// @param A call class to be decorated by this class.
+ ///
+ abstract sealed class Base implements CallDecorator permits AssertionCall, RetryCall, EnsuredCall {
+ private final C target;
+
+ ///
+ /// Creates an object of this class.
+ ///
+ /// @param target A target class to be decorated.
+ ///
+ protected Base(C target) {
+ this.target = requireNonNull(target);
+ }
+
+ @Override
+ public C targetCall() {
+ return this.target;
+ }
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/EnsuredCall.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/EnsuredCall.java
new file mode 100644
index 0000000..a3a3337
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/EnsuredCall.java
@@ -0,0 +1,79 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Action;
+import com.github.dakusui.actionunit.core.Context;
+import jp.co.moneyforward.autotest.framework.annotations.PreparedBy;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+
+///
+/// A class to provide a construct to "ensure" a specific state checked by `target` call.
+///
+/// Each element in `ensurers` is performed first, then `target` is performed.
+/// This procedure is repeated until:
+///
+/// * Both an element from `ensurers` and the `target` are successfully performed.
+/// * Either an element from `ensurer` or the `target` throws a non-recoverable exception.
+///
+/// `target` should be a call to an action, which succeeds when and only when the state you want to ensure is satisfied.
+/// Each element in `ensurers` should be an action that tries to make the state meet your expectation.
+/// The ensurers should be sorted by an ascending order of their execution cost.
+///
+/// @see PreparedBy
+/// @see EnsuredCall#EnsuredCall(SceneCall, List, ResolverBundle) EnsuredCall
+///
+public final class EnsuredCall extends CallDecorator.Base {
+ private final List ensurers;
+ private final ResolverBundle resolverBundle;
+
+ ///
+ /// Creates an object of this class.
+ ///
+ /// @param target A target class to be decorated.
+ ///
+ public EnsuredCall(SceneCall target, List ensurers, ResolverBundle resolverBundle) {
+ super(target);
+ this.ensurers = List.copyOf(requireNonNull(ensurers));
+ this.resolverBundle = resolverBundle;
+ }
+
+ @Override
+ public Action toAction(ActionComposer actionComposer) {
+ return actionComposer.create(this);
+ }
+
+ ///
+ /// Returns "ensurer" calls.
+ ///
+ /// @return A list of "ensurer" calls.
+ ///
+ public List ensurers() {
+ return this.ensurers;
+ }
+
+ ///
+ /// DUPLICATED!!
+ /// Returns a map (variable store), with which a targetScene can interact to store/read data.
+ /// Initial values of variables are resolved by giving a `context` parameter value to each element in `resolverBundle`.
+ ///
+ /// @param ensuredCall A scene call for which a returned map is created.
+ /// @param context A context in which actions created from the target scene are performed.
+ /// @return A data store map.
+ /// @see ResolverBundle
+ ///
+ private static Map composeWorkingVariableStore(EnsuredCall ensuredCall,
+ Context context) {
+ var ret = new HashMap();
+ ensuredCall.resolverBundle()
+ .forEach((k, r) -> ret.put(k, r.apply(context)));
+ return ret;
+ }
+
+ private ResolverBundle resolverBundle() {
+ return this.resolverBundle;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/Resolver.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/Resolver.java
new file mode 100644
index 0000000..183ccaa
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/Resolver.java
@@ -0,0 +1,62 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Context;
+import com.github.valid8j.pcond.forms.Printables;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+import static java.lang.String.format;
+
+///
+/// `Resolver` figures out a variable designated by `variableName` in a context.
+/// Note that a resolver takes a variable name only, and it returns a value for a given variable name.
+///
+/// A resolver provides a "namespace" of variables available for a scene.
+///
+/// @param variableName A name of a variable whose value is to be resolved by this object.
+/// @param resolverFunction A function that resolves the value.
+///
+public record Resolver(String variableName, Function resolverFunction) {
+ ///
+ /// Typically, this function is called by a method `resolverFor` and the `variableName` passed to it should be used as `variableNameInScene` for this method.
+ ///
+ /// @param variableName A name of a variable whose value is to be resolved.
+ /// @param variableStoreName A name of a scene in which the value of the variable is resolved.
+ /// @return A function that gives the value of `variableNameInScene` from a `Context` object.
+ ///
+ public static Function resolver(String variableName, String variableStoreName) {
+ return Printables.function(format("resolve[%s][%s]", variableName, variableStoreName),
+ context -> context.defined(variableStoreName) ? context.>valueOf(variableStoreName).get(variableName)
+ : null);
+ }
+
+ ///
+ /// Returns a `Resolver` object, which resolves a value of a variable designated by `variableName` exported by a scene `sceneName`.
+ /// A `sceneName` must be a name of a scene, which is guaranteed to be performed one and only once during one test execution.
+ ///
+ /// @param variableName A name of a variable to be resolved by the returned `Resolver`.
+ /// @param variableStoreName A name of a scene by which `variableName` is exported.
+ /// @return A `Resolver` object.
+ ///
+ public static Resolver resolverFor(String variableName, String variableStoreName) {
+ return new Resolver(variableName, resolver(variableName, variableStoreName));
+ }
+
+ ///
+ /// Returns a list of resolvers for variables specified by `variableNames`.
+ /// Resolvers in the list try to find a variable in a variable store specified by `variableStoreName`.
+ ///
+ /// @param variableNames Names of variables to be resolved by returned resolvers.
+ /// @param variableStoreName A name of variable store from which values of variables are looked up.
+ /// @return A list of resolvers.
+ ///
+ public static List resolversFor(List variableNames, String variableStoreName) {
+ requireNonNull(variableStoreName);
+ return variableNames.stream()
+ .map(n -> new Resolver(n, (Context c) -> c.>valueOf(variableStoreName).get(n)))
+ .toList();
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/ResolverBundle.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/ResolverBundle.java
new file mode 100644
index 0000000..c869a79
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/ResolverBundle.java
@@ -0,0 +1,192 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Context;
+import jp.co.moneyforward.autotest.framework.annotations.DependsOn;
+import jp.co.moneyforward.autotest.framework.annotations.Export;
+import jp.co.moneyforward.autotest.framework.annotations.PreparedBy;
+import jp.co.moneyforward.autotest.framework.annotations.When;
+import jp.co.moneyforward.autotest.framework.utils.InternalUtils;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.Collections.emptyList;
+import static jp.co.moneyforward.autotest.framework.testengine.AutotestEngine.findMethodByName;
+
+///
+/// A bundle of variable resolvers.
+///
+/// A variable resolver figures out a value of a variable specified by a variable name.
+/// This class bundles a set of such resolvers and associated each resolver with a variable name which the resolver
+/// should figure out the value.
+///
+public class ResolverBundle extends HashMap> {
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param resolvers A map of resolvers from variable names to resolvers.
+ ///
+ public ResolverBundle(Map> resolvers) {
+ super(resolvers);
+ }
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param resolvers A list of resolvers from which an object of this class will be created.
+ ///
+ public ResolverBundle(List resolvers) {
+ this(resolversToMap(resolvers));
+ }
+
+ ///
+ /// Returns a resolver bundle object which figures out both input and output variable values for a given `Scene`.
+ /// The variables are looked up from a variable store specified by the argument `variableStoreName`.
+ ///
+ /// For each input or output variable, a resolver will be created, and it will be an element of the returned bundle.
+ ///
+ /// @param scene A scene for which resolver bundle is created.
+ /// @param variableStoreName A name of variable store, where variable values are looked up.
+ /// @return A new resolver bundle.
+ ///
+ public static ResolverBundle resolverBundleFor(Scene scene, String variableStoreName) {
+ return new ResolverBundle(createVariableResolversFor(scene, variableStoreName));
+ }
+
+ ///
+ /// Returns a resolver bundle which is necessary for creating a new `SceneCall` call from a `Scene` defined by
+ /// `targetMethod`.
+ ///
+ /// @param targetMethod A method which creates a `Scene`.
+ /// @param accessModelClass A class to which `targetMethod` belongs and from which dependencies of `target` method are
+ /// searched.
+ /// @return A resolver bundle for a `Scene` created by `targetMethod`.
+ ///
+ public static ResolverBundle resolverBundleFromDependenciesOf(Method targetMethod, Class accessModelClass) {
+ assert Scene.class.isAssignableFrom(targetMethod.getReturnType());
+ return new ResolverBundle(resolversFromDependenciesOf(targetMethod, accessModelClass));
+ }
+
+ ///
+ /// Returns an empty resolver bundle.
+ ///
+ /// @return An empty resolver bundle.
+ ///
+ public static ResolverBundle emptyResolverBundle() {
+ return new ResolverBundle(List.of());
+ }
+
+ ///
+ /// Returns a variable resolvers of a given `scene` based on its children's input and output variable names.
+ /// The returned variable resolvers figure out the value of a given variable name from a Map context variable.
+ /// The context variable is specified by a `variableStoreName`.
+ ///
+ /// This is "de facto"-based method to create variable resolvers, so to say.
+ ///
+ /// @param scene A scene for which variable resolvers are created and returned.
+ /// @param variableStoreName A name of a context variable that stores a map.
+ /// From the map, the returned resolvers figure out the values of given variable names,
+ /// which are used by the scene.
+ /// @return A list of variable resolvers.
+ ///
+ private static List createVariableResolversFor(Scene scene, String variableStoreName) {
+ return Resolver.resolversFor(Stream.concat(scene.inputVariableNames().stream(),
+ scene.outputVariableNames().stream())
+ .distinct()
+ .toList(), variableStoreName
+ );
+ }
+
+ ///
+ /// Creates resolvers (`Resolver`) for a scene call associated with a scene returned by `method`.
+ ///
+ /// Either `@DependsOn` or `@When` annotations attached to `method` tells the framework that methods which it depends on.
+ /// This method scans `@Export` attached to those methods to figure out variables available to the `method`.
+ ///
+ /// This is "de juro"-based method to create variable resolvers, so to say.
+ ///
+ /// @param method A method that returns a `Scene` object.
+ /// @param accessModelClass An access model class to which method belongs.
+ /// @return A list of resolvers that a scene returned by `method` requires.
+ ///
+ private static List resolversFromDependenciesOf(Method method, Class accessModelClass) {
+ return InternalUtils.concat(variableResolversFor(annotationValuesOf(method, PreparedBy.class, PreparedBy::value), accessModelClass).stream(),
+ variableResolversFor(annotationValuesOf(method, DependsOn.class, DependsOn::value), accessModelClass).stream(),
+ variableResolversFor(annotationValuesOf(method, When.class, When::value), accessModelClass).stream()).toList();
+ }
+
+ private static String[] annotationValuesOf(Method method, Class annotationClass, Function func) {
+ A[] annotationsByType = method.getAnnotationsByType(annotationClass);
+ if (annotationsByType.length == 0)
+ return new String[0];
+ return Arrays.stream(annotationsByType).flatMap(a -> Arrays.stream(func.apply(a))).toArray(String[]::new);
+ }
+
+ ///
+ /// Returns a list of variable resolvers (`Resolver`) for scenes specified by their names (`sceneNames).
+ ///
+ /// Creates variable resolvers for a scene created from a method `m`.
+ ///
+ /// The scene created by `m` will be called "scene `m`" in this description, hereafter.
+ /// Variable resolvers created based on annotations specified by `dependencyAnnotationClass`, which is usually `@DependsOn`.
+ ///
+ /// @param sceneNames Scenes for which variable resolvers are searched, created, and returned.
+ /// @param accessModelClass An access model class that defines a set of scene creating methods, on which `m` potentially depends.
+ /// @return Resolvers for a scene created by `m`.
+ /// @see Resolver
+ ///
+ private static List variableResolversFor(String[] sceneNames, Class accessModelClass) {
+ if (sceneNames.length == 0)
+ return emptyList();
+ return variableResolversFor(sceneNames,
+ dependencySceneName -> exportedVariablesOf(methodForName(dependencySceneName, accessModelClass)));
+ }
+
+ ///
+ /// Returns `Resolver`s for variables exported by scenes specified by `sceneNames`.
+ /// A resolver in the list returns a value of a variable defined in a scene that exports it with the same name.
+ ///
+ /// @param sceneNames Names of `Scene`s.
+ /// @param exportedVariableNamesResolver A function that returns a list of exported variable names by a scene specified as a parameter.
+ /// @return `Resolver`s for variables exported by specified scenes.
+ ///
+ private static List variableResolversFor(String[] sceneNames,
+ Function> exportedVariableNamesResolver) {
+ return Arrays.stream(sceneNames)
+ .flatMap((String sceneName) -> exportedVariablesResolversOf(sceneName, exportedVariableNamesResolver).stream())
+ .toList();
+ }
+
+ private static List exportedVariablesResolversOf(String sceneName, Function> exportedVariablesNamesResolver) {
+ return exportedVariablesNamesResolver.apply(sceneName)
+ .stream()
+ .map((String variableNane) -> Resolver.resolverFor(variableNane, sceneName)).toList();
+ }
+
+ private static List exportedVariablesOf(Method method) {
+ return List.of(method.getAnnotation(Export.class).value());
+ }
+
+ private static Map> resolversToMap(List resolvers) {
+ Map> resolverMap = new HashMap<>();
+ for (Resolver resolver : resolvers) {
+ resolverMap.put(resolver.variableName(), resolver.resolverFunction());
+ }
+ return resolverMap;
+ }
+
+ private static Method methodForName(String methodName, Class classObject) {
+ return findMethodByName(methodName,
+ classObject).orElseThrow(() -> messageForNoSuchMethod(classObject, methodName));
+ }
+
+
+ private static NoSuchElementException messageForNoSuchMethod(Class accessModelClass, String dependencySceneName) {
+ return new NoSuchElementException(String.format("A method named:'%s' was not found in class:'%s'",
+ dependencySceneName,
+ accessModelClass.getCanonicalName()));
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/RetryCall.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/RetryCall.java
new file mode 100644
index 0000000..165b775
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/RetryCall.java
@@ -0,0 +1,44 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Action;
+
+import java.util.concurrent.TimeUnit;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+public final class RetryCall extends CallDecorator.Base {
+ private final int interval;
+ private final int retryTimes;
+ private final Class onExceptionType;
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ public RetryCall(Call target, Class onExceptionType, int retryTimes, int interval) {
+ super(target);
+ this.interval = interval;
+ this.retryTimes = retryTimes;
+ this.onExceptionType = onExceptionType;
+ }
+
+ @Override
+ public Action toAction(ActionComposer actionComposer) {
+ return actionComposer.create(this);
+ }
+
+ public int times() {
+ return retryTimes;
+ }
+
+ public Class onException() {
+ return onExceptionType;
+ }
+
+ public long interval() {
+ return interval;
+ }
+
+ public TimeUnit intervalUnit() {
+ return SECONDS;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/Scene.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/Scene.java
new file mode 100644
index 0000000..c096f78
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/Scene.java
@@ -0,0 +1,519 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Action;
+import com.github.dakusui.actionunit.core.ActionSupport;
+import com.github.valid8j.pcond.fluent.Statement;
+import jp.co.moneyforward.autotest.actions.web.Value;
+import jp.co.moneyforward.autotest.framework.utils.InternalUtils;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
+
+import static com.github.dakusui.actionunit.core.ActionSupport.sequential;
+import static com.github.valid8j.classic.Requires.requireNonNull;
+import static java.util.Arrays.asList;
+import static jp.co.moneyforward.autotest.framework.action.AutotestSupport.*;
+import static jp.co.moneyforward.autotest.framework.utils.InternalUtils.simpleClassNameOf;
+
+///
+/// An interface that represents a reusable unit of an action in **insdog**'s programming model.
+/// An instance of this object contains 0 or more {@link Act} instances.
+///
+/// Note that `Scene` uses the same map for both input and output.
+///
+public interface Scene extends WithOid {
+ ///
+ /// A default value of default variable name for `Scene.Builder` and `@Export`.
+ /// This value is currently defined `page` for historical reason.
+ /// However, **InspektorDog** is designed not only for GUI end-to-end test, but a general purpose testing framework.
+ /// The value should be changed to a more context neutral keyword, such as `var` or `session`.
+ ///
+ String DEFAULT_DEFAULT_VARIABLE_NAME = "page";
+
+ ///
+ /// // @formatter:off
+ /// A synonym of `new Scene.Builder()`.
+ /// Use this in combination with `Scene#end()` so that your code looks like:
+ ///
+ /// ```java
+ /// class YourClass {
+ /// void method() {
+ /// Scene.begin()
+ /// .act(yourAct())
+ /// .assertion(s -> s.then().looksOkay())
+ /// .end()
+ /// }
+ /// }
+ /// ```
+ ///
+ /// // @formatter:on
+ ///
+ /// @return A new `Scene.Builder` object.
+ ///
+ static Scene.Builder begin() {
+ return begin(DEFAULT_DEFAULT_VARIABLE_NAME);
+ }
+
+ static Scene.Builder begin(String defaultVariableName) {
+ return new Builder(defaultVariableName);
+ }
+
+ ///
+ /// Creates a scene by chaining acts.
+ /// When you need to handle multiple variables, use {@link Scene.Builder} directly.
+ ///
+ /// @param variableName A variable chained acts read input value from and write output value to.
+ /// @param acts Acts from which a scene is created.
+ /// @return Created scene.
+ ///
+ static Scene create(String variableName, Act... acts) {
+ Scene.Builder b = new Builder(variableName);
+ for (Act act : acts) {
+ b.add(act);
+ }
+ return b.build();
+ }
+
+ ///
+ /// Creates a scene by chaining acts.
+ /// This method internally calls {@link Scene#create(String, Act[])} using {@link Scene#DEFAULT_DEFAULT_VARIABLE_NAME} as a `variableName`.
+ ///
+ /// When you need to handle other variables, use {@link Scene#create(String, Act[])} or {@link Scene.Builder}, instead.
+ ///
+ /// @param acts Acts from which a scene is created.
+ /// @return Created scene.
+ ///
+ static Scene create(Act... acts) {
+ return create(Scene.DEFAULT_DEFAULT_VARIABLE_NAME, acts);
+ }
+
+ ///
+ /// Creates a sequential action from the child calls of this object
+ ///
+ /// @param actionComposer A visitor that builds a sequential action from child calls of this object.
+ /// @return A sequential action created from child calls
+ /// @see Scene#children()
+ ///
+ default Action toSequentialAction(ActionComposer actionComposer) {
+ return sequential(toActions(actionComposer));
+ }
+
+ ///
+ /// Returns members of this scene object, which are executed as "children".
+ ///
+ /// @return members of this scene object.
+ ///
+ List children();
+
+ ///
+ /// Returns an object identifier of this object.
+ ///
+ /// @return An object identifier of this object.
+ ///
+ String oid();
+
+ ///
+ /// Returns a name of this object.
+ /// The returned string will appear in an action tree printed during the action execution.
+ ///
+ /// @return A name of this object.
+ ///
+ default String name() {
+ return simpleClassNameOf(this.getClass());
+ }
+
+ ///
+ /// Returns a list of variables that are assigned by child scenes of this object.
+ ///
+ /// @return A list of variables that are assigned by child scenes of this object.
+ ///
+ default List outputVariableNames() {
+ return this.children()
+ .stream()
+ .flatMap(Scene::outputVariableNamesOf)
+ .distinct()
+ .toList();
+ }
+
+ ///
+ /// Returns a list of variables that are accessed by child scenes of this object.
+ ///
+ /// @return A list of variables that are accessed by child scenes of this object.
+ ///
+ default List inputVariableNames() {
+ return this.children()
+ .stream()
+ .flatMap(Scene::inputVariableNamesOf)
+ .distinct()
+ .toList();
+ }
+
+ private static Stream outputVariableNamesOf(Call call) {
+ return switch (call) {
+ case SceneCall sceneCall -> sceneCall.targetScene().outputVariableNames().stream();
+ case ActCall actCall -> Stream.of(actCall.outputVariableName());
+ case EnsuredCall ensuredCall -> outputVariableNamesOf(ensuredCall);
+ case CallDecorator callDecorator -> outputVariableNamesOf(callDecorator.targetCall());
+ };
+ }
+
+ private static Stream outputVariableNamesOf(EnsuredCall ensuredCall) {
+ return Stream.concat(outputVariableNamesOf(ensuredCall.targetCall()),
+ ensuredCall.ensurers()
+ .stream()
+ .flatMap(Scene::outputVariableNamesOf)).distinct();
+ }
+
+ private static Stream inputVariableNamesOf(Call call) {
+ return switch (call) {
+ case SceneCall sceneCall -> sceneCall.targetScene().inputVariableNames().stream();
+ case ActCall actCall -> Stream.of(actCall.inputVariableName());
+ case EnsuredCall ensuredCall -> inputVariableNamesOf(ensuredCall);
+ case CallDecorator callDecorator -> inputVariableNamesOf(callDecorator.targetCall());
+ };
+ }
+
+ private static Stream inputVariableNamesOf(EnsuredCall ensuredCall) {
+ return Stream.concat(inputVariableNamesOf(ensuredCall.targetCall()),
+ ensuredCall.ensurers()
+ .stream()
+ .flatMap(Scene::inputVariableNamesOf)).distinct();
+ }
+
+ private List toActions(ActionComposer actionComposer) {
+ return children().stream()
+ .map((Call each) -> each.toAction(actionComposer))
+ .flatMap(InternalUtils::flattenIfSequential)
+ .toList();
+ }
+
+ ///
+ /// A builder for `Scene` class.
+ ///
+ /// @see Scene
+ ///
+ class Builder implements WithOid {
+ final String defaultVariableName;
+ private final List children = new LinkedList<>();
+ private String name = null;
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// Note that `defaultVariableName` is only used by this `Builder`, not directly by the `Scene` built by this object.
+ ///
+ /// @param defaultVariableName A name of field used when use `add` methods without explicit input/output target field names.
+ ///
+ public Builder(String defaultVariableName) {
+ this.defaultVariableName = defaultVariableName;
+ }
+
+ ///
+ /// Creates an instance of this class.
+ /// If you add an act to this object without explicitly specifying variable name with which the act interacts,
+ /// a `NullPointerException` will be thrown.
+ ///
+ public Builder() {
+ this(DEFAULT_DEFAULT_VARIABLE_NAME);
+ }
+
+ ///
+ /// Sets a name of a scene built by this builder object.
+ ///
+ /// @param name A name of a scene.
+ /// @return This object.
+ ///
+ public Builder name(String name) {
+ this.name = requireNonNull(name);
+ return this;
+ }
+
+ ///
+ /// // @formatter:off
+ /// A "syntax-sugar" method to group a sequence of method calls to this `Builder` object.
+ ///
+ /// That is, you can do:
+ ///
+ /// ```java
+ /// new SceneBuilder.with(b -> b.add(...)
+ /// .add(...)
+ /// .add(...))
+ /// .build();
+ /// ```
+ ///
+ /// Note that the operator `op` is supposed to return `this` object.
+ ///
+ /// // @formatter:on
+ /// @param op A unary operator that groups operator on this object.
+ /// @return This object returned by `op`.
+ ///
+ public final Builder with(UnaryOperator op) {
+ return op.apply(this);
+ }
+
+ ///
+ /// Adds an `Act` to this builder.
+ /// `defaultFieldName` is used for both input and output.
+ /// Note that in case `T` and `R` are different, the field will have a different type after `leafAct` execution from the value before it is executed.
+ ///
+ /// @param act An act object to be added to this builder.
+ /// @param Type of input parameter field.
+ /// @param Type of output parameter field.
+ /// @return This object.
+ ///
+ public final Builder add(Act act) {
+ return this.add(defaultVariableName(), act, defaultVariableName());
+ }
+
+ ///
+ /// Synonym of {@link Builder#add(Act)}.
+ ///
+ /// Prefer this over `Builder#add(Act)` as usage of this method results in more readable code in general.
+ /// This method is also useful for languages that run on JVM, but doesn't have method overloading.
+ ///
+ /// @param act An act to be added.
+ /// @return This object
+ ///
+ public final Builder act(Act act) {
+ return this.add(defaultVariableName(), act, defaultVariableName());
+ }
+
+ ///
+ /// Adds an act to this builder.
+ /// The output of an act goes to a variable specified by `outputVariableName` in the scene's variable store.
+ ///
+ /// @param outputVariableName A variable name `act`'s output goes to.
+ /// @param act An `Act` to be added.
+ /// @param Input type of `act`.
+ /// @param Output type of `act`.
+ /// @return This object
+ ///
+ public final Builder add(String outputVariableName, Act act) {
+ return this.add(outputVariableName, act, defaultVariableName());
+ }
+
+ ///
+ /// Adds an `act` to this object so that it takes input from `inputVariableName` and writes output to `outputVariableName`.
+ ///
+ /// @param outputVariableName A string to specify an output variable.
+ /// @param act An `Act` to be added to this object.
+ /// @param inputVariableName A string to specify an input variable.
+ /// @param An input value type
+ /// @param An output value type
+ /// @return This object
+ ///
+ public final Builder add(String outputVariableName, Act act, String inputVariableName) {
+ return this.addCall(actCall(outputVariableName, act, inputVariableName));
+ }
+
+ ///
+ /// Adds a function `assertion` to this builder object.
+ ///
+ /// @param assertion An assertion to be added to this object.
+ /// @param Type of value to be checked by `assertion`.
+ /// @return This object.
+ ///
+ @SuppressWarnings("unchecked")
+ public final Builder assertion(Function> assertion) {
+ return this.assertions(assertion);
+ }
+
+ ///
+ /// Adds `assertions` to this builder object.
+ ///
+ /// @param assertions Functions that generates statements to be added.
+ /// @param Type of the value to be verified.
+ /// @return This object.
+ ///
+ @SuppressWarnings("unchecked")
+ public final Builder assertions(Function>... assertions) {
+ return this.assertions(defaultVariableName(), assertions);
+ }
+
+ ///
+ /// Returns an `AssertionAct` object that verifies a variable in a currently ongoing scene call's variable store.
+ /// The variable in the store is specified by `inputFieldName`.
+ /// This method is implemented as:
+ ///
+ /// `this.addCall(assertionCall(variableName, new Value<>(), singletonList(assertionAct), variableName))`,
+ /// where `Value` is a trivial act which just copies its input variable to an output variable.
+ ///
+ /// @param Type of the variable specified by `inputVariableName`.
+ /// @param variableName A name of an input variable to be verified.
+ /// @param assertions An assertion function
+ /// @return This object
+ ///
+ @SuppressWarnings("unchecked")
+ public final Builder assertions(String variableName, Function>... assertions) {
+ return this.addCall(assertionCall(variableName, new Value<>(), asList(assertions), variableName));
+ }
+
+ ///
+ /// Adds a given `scene` to this builder object.
+ /// A call to the `scene` will be created (a `SceneCall` object), and it will be a child of the scene that this builder builds.
+ ///
+ /// The child call will use the working variable store of the parent scene (i.e., a scene built by this builder) as its input variable store.
+ /// With this mechanism, the child can reference the values of the
+ ///
+ /// @param scene A scene to be added.
+ /// @return This object,
+ ///
+ public final Builder add(Scene scene) {
+ return this.addCall(toSceneCall(scene));
+ }
+
+ ///
+ /// Synonym of {@link Builder#add(Scene)}.
+ ///
+ /// Prefer this over `Builder#add(Scene)` as usage of this method results in more readable code in general.
+ /// This method is also useful for languages that run on JVM, but doesn't have method overloading.
+ ///
+ /// @param scene A scene to be added.
+ /// @return This object
+ ///
+ public final Builder scene(Scene scene) {
+ return this.add(scene);
+ }
+
+ ///
+ /// Adds a call that retries a given `call`.
+ /// The call retries given `times` on a failure designated by a class `onException`.
+ /// An interval between tries will be `interval` seconds.
+ ///
+ /// Note that `times` means number of "RE"-tries.
+ /// If you give 1, it will be retried once after `interval` seconds, if the first try fails.
+ ///
+ /// @param call A call to be retried
+ /// @param times Number of retries at maximum.
+ /// @param onException An exception class on which retries should be attempted.
+ /// @param interval Interval between tries.
+ /// @return A call that retries a given `call`.
+ ///
+ public final Builder retry(Call call, int times, Class onException, int interval) {
+ return this.addCall(AutotestSupport.retryCall(call, times, onException, interval));
+ }
+
+ ///
+ /// This method is implemented as a shorthand for `this.retry(call, times, onException, 5)`.
+ ///
+ /// @param call A call to be retried
+ /// @param times How many times `call` should be retried until it succeeds.
+ /// @return This object
+ ///
+ public final Builder retry(Call call, int times, Class onException) {
+ return retry(call, times, onException, 5);
+ }
+
+ ///
+ /// This method is implemented as a shorthand for `this.retry(call, times, AssertionFailedError.class)`.
+ ///
+ /// @param call A call to be retried
+ /// @param times How many times `call` should be retried until it succeeds.
+ /// @return This object
+ ///
+ public final Builder retry(Call call, int times) {
+ return retry(call, times, Throwable.class);
+ }
+
+ ///
+ /// Adds a scene that retries a given `scene` twice.
+ /// Note that, `scene` is attempted three times in total.
+ ///
+ /// @param scene A scene to be added and retried on a failure.
+ /// @return This object
+ ///
+ public final Builder retry(Scene scene) {
+ return retry(toSceneCall(scene));
+ }
+
+ ///
+ /// This method is implemented as a shorthand for `this.retry(call, 2)`.
+ ///
+ /// @param call A call object to be added.
+ /// @return This object.
+ ///
+ public final Builder retry(Call call) {
+ return retry(call, 2);
+ }
+
+ ///
+ /// Adds a call to this object as a child.
+ /// You need to ensure that requirements of `call` are satisfied in the context it will be run by yourself.
+ ///
+ /// For instance, if the call is a `SceneCall`, the variable store from which it reads needs to be prepared beforehand by one of preceding calls.
+ ///
+ /// @param call A `Call` object to be added.
+ /// @return This object.
+ ///
+ public Builder addCall(Call call) {
+ this.children.add(call);
+ return this;
+ }
+
+ ///
+ /// Builds a `Scene` object.
+ ///
+ /// @return A `Scene` object.
+ ///
+ public Scene build() {
+ return new Scene() {
+ private final List children = Builder.this.children;
+ private final String oid = Builder.this.oid();
+
+ @Override
+ public List children() {
+ return children;
+ }
+
+ @Override
+ public String oid() {
+ return oid;
+ }
+
+ @Override
+ public String toString() {
+ return name() + "@" + oid();
+ }
+
+ @Override
+ public String name() {
+ return name != null ? name
+ : Scene.super.name();
+ }
+ };
+ }
+
+ ///
+ /// A synonym of {@link Builder#build()}.
+ /// Use this with {@link Scene#begin()}.
+ ///
+ /// @return A new scene object
+ /// @see Builder#build()
+ /// @see Scene#begin()
+ ///
+ public Scene end() {
+ return build();
+ }
+
+ ///
+ /// Returns an object identifier of this object.
+ ///
+ /// @return An object identifier of this object.
+ ///
+ @Override
+ public String oid() {
+ return "id-" + System.identityHashCode(this);
+ }
+
+ private String defaultVariableName() {
+ return requireNonNull(this.defaultVariableName);
+ }
+
+ private SceneCall toSceneCall(Scene scene) {
+ return sceneToSceneCall(scene, this.workingVariableStoreName());
+ }
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/SceneCall.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/SceneCall.java
new file mode 100644
index 0000000..488efce
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/SceneCall.java
@@ -0,0 +1,152 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import com.github.dakusui.actionunit.core.Action;
+import com.github.dakusui.actionunit.core.Context;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+import static jp.co.moneyforward.autotest.framework.utils.InternalUtils.action;
+import static jp.co.moneyforward.autotest.framework.utils.InternalUtils.trivialAction;
+
+///
+/// A class to model a "call" to a `Scene`.
+///
+public final class SceneCall implements Call, WithOid {
+ private final Scene scene;
+ private final ResolverBundle resolverBundle;
+ private final String outputVariableStoreName;
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// outputVariableStoreName specifies a name of a context variable (**actionunit**), to which the output of `scene`
+ /// is written.
+ ///
+ /// `resolverBundle` is used to compute input variable values.
+ ///
+ /// @param scene A scene to be performed by this call.
+ /// @param resolverBundle A bundle of resolvers.
+ /// @param outputVariableStoreName A name of variable store, to which the `scene` writes its output.
+ ///
+ public SceneCall(Scene scene,
+ ResolverBundle resolverBundle,
+ String outputVariableStoreName) {
+ this.outputVariableStoreName = requireNonNull(outputVariableStoreName);
+ this.scene = requireNonNull(scene);
+ this.resolverBundle = requireNonNull(resolverBundle);
+ }
+
+ @Override
+ public Action toAction(ActionComposer actionComposer) {
+ return actionComposer.create(this);
+ }
+
+ ///
+ /// Returns an object identifier of this object.
+ ///
+ /// @return An object identifier of this object.
+ ///
+ @Override
+ public String oid() {
+ return this.targetScene().oid();
+ }
+
+ ///
+ /// Returns a `Scene` object targeted by this call.
+ ///
+ /// @return A `Scene` object.
+ ///
+ public Scene targetScene() {
+ return this.scene;
+ }
+
+ ///
+ /// A name of "output" variable store, where this `SceneCall` writes its final result at the end of execution.
+ ///
+ /// @return A name of variable store, which this `SceneCall` writes its result to.
+ ///
+ public String outputVariableStoreName() {
+ return this.outputVariableStoreName;
+ }
+
+ ///
+ /// Returns a bundle of variable resolvers of this object.
+ ///
+ /// @return A bundle of variable resolvers.
+ ///
+ public ResolverBundle resolverBundle() {
+ return resolverBundle;
+ }
+
+ ///
+ /// Returns currently ongoing working variable store.
+ ///
+ /// @param context A context in which this call is being executed.
+ /// @return A currently ongoing working variable store.
+ ///
+ public Map workingVariableStore(Context context) {
+ return context.valueOf(this.workingVariableStoreName());
+ }
+
+ ///
+ /// Returns an action, which marks the beginning of a sequence of main actions.
+ ///
+ /// The action copies a map of the InsDog's framework variables for this scene call to a context variable whose name
+ /// is computed by `workingVariableStoreNameFor(this.targetScene().oid())`.
+ ///
+ /// @return An action, which marks the beginning of a sequence of main actions.
+ ///
+ public Action begin(List ongoingWorkingVariableStoreNames) {
+ try {
+ String ongoingWorkingVariableStoreName = ongoingWorkingVariableStoreNames.isEmpty() ? null
+ : ongoingWorkingVariableStoreNames.getLast();
+ return action("output:[" + outputVariableStoreName() + "] work:[" + workingVariableStoreName() + "]",
+ c -> c.assignTo(workingVariableStoreName(),
+ composeWorkingVariableStore(ongoingWorkingVariableStoreName,
+ this,
+ c)));
+ } finally {
+ ongoingWorkingVariableStoreNames.add(workingVariableStoreName());
+ }
+ }
+
+ ///
+ /// Returns an action, which marks an ending of a sequence of main actions.
+ ///
+ /// The action copies to a map of the InsDog's framework variables for this scene call from a context variable whose
+ /// name is computed by `workingVariableStoreNameFor(this.targetScene().oid())`.
+ ///
+ /// @return An action, which marks an ending of a sequence of main actions.
+ ///
+ public Action end(List ongoingWorkingVariableStoreNames) {
+ ongoingWorkingVariableStoreNames.removeLast();
+ return trivialAction("END[" + outputVariableStoreName() + "]", c -> {
+ c.assignTo(outputVariableStoreName(), c.valueOf(workingVariableStoreName()));
+ c.unassign(workingVariableStoreName());
+ });
+ }
+
+ // Copies the map stored as "work area" to `outputFieldName` variable.
+
+ ///
+ /// Returns a map (variable store), with which a targetScene can interact to store/read data.
+ /// Initial values of variables are resolved by giving a `context` parameter value to each element in `resolverBundle`.
+ ///
+ /// @param sceneCall A scene call for which a returned map is created.
+ /// @param context A context in which actions created from the target scene are performed.
+ /// @return A data store map.
+ /// @see ResolverBundle
+ ///
+ private static Map composeWorkingVariableStore(String ongoingWorkingVariableStoreName,
+ SceneCall sceneCall,
+ Context context) {
+ Map ret = context.defined(ongoingWorkingVariableStoreName) ? context.valueOf(ongoingWorkingVariableStoreName)
+ : new HashMap<>();
+ sceneCall.resolverBundle()
+ .forEach((k, r) -> ret.put(k, r.apply(context)));
+ return ret;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/Wait.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/Wait.java
new file mode 100644
index 0000000..a38f6d4
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/Wait.java
@@ -0,0 +1,51 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.TimeUnit;
+
+import static java.util.Objects.requireNonNull;
+
+///
+/// Use this only when you have no other choices.
+///
+/// @param The type of the variable to handle.
+///
+public class Wait implements Act {
+ private static final Logger LOGGER = LoggerFactory.getLogger(Wait.class);
+ private final int time;
+ private final TimeUnit unit;
+ private final String excuse;
+
+ ///
+ /// Creates an instance of this class.
+ ///
+ /// @param time Time to wait.
+ /// @param unit Unit of the time.
+ /// @param excuse An excuse to use this class.
+ ///
+ public Wait(int time, TimeUnit unit, String excuse) {
+ this.time = time;
+ this.unit = requireNonNull(unit);
+ this.excuse = requireNonNull(excuse);
+ }
+
+ @Override
+ public T perform(T value, ExecutionEnvironment executionEnvironment) {
+ try {
+ Thread.sleep(unit.toMillis(time));
+ } catch (InterruptedException e) {
+ LOGGER.error("Sleep was interrupted");
+ LOGGER.debug("- Stacktrace:", e);
+ Thread.currentThread().interrupt();
+ }
+ return value;
+ }
+
+ @Override
+ public String name() {
+ return "Wait(because:" + this.excuse + ")[" + time + " " + unit + "]";
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/WithOid.java b/src/main/java/jp/co/moneyforward/autotest/framework/action/WithOid.java
new file mode 100644
index 0000000..0a95741
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/WithOid.java
@@ -0,0 +1,20 @@
+package jp.co.moneyforward.autotest.framework.action;
+
+public interface WithOid {
+ ///
+ /// Returns an object identifier of this object.
+ ///
+ /// @return An object identifier of this object.
+ ///
+ String oid();
+
+ ///
+ /// Returns a working variable store name for the object ID of this instance.
+ ///
+ /// @return A working variable store name.
+ ///
+ default String workingVariableStoreName() {
+ String objectId = oid();
+ return "work-" + objectId;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/action/package-info.md b/src/main/java/jp/co/moneyforward/autotest/framework/action/package-info.md
new file mode 100644
index 0000000..606e4e0
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/action/package-info.md
@@ -0,0 +1,275 @@
+This is a package to provide "action" model of the **InsDog** framework.
+
+Actions performed over the SUT are modeled as `Call` and `Act` in the framework, which creates `Action` using the concept of **actionunit** library.
+
+```mermaid
+classDiagram
+ namespace ActionVisitor {
+ class ActionComposer {
+ <>
+ create(ActCall call) Action
+ create(AssertionActCall call) Action
+ create(SceneCall call) Action
+ }
+ }
+
+ namespace Scenes {
+ class Scene {
+ }
+ class Scene_Builder {
+ build() Scene
+ }
+ }
+ Scene_Builder "build" ..> Scene
+ Scene_Builder ..> Call
+
+ namespace Calls {
+ class Call {
+ <>
+ <>
+ Action toAction(ActionComposer)
+ }
+ class SceneCall
+ class Decorator~C extends Call~
+ class RetryCall~C extends Call~
+ class AssertionCall
+ class EnsuredCall
+ class ActCall
+ }
+ Call <|-- SceneCall
+ Call <|-- Decorator
+ Decorator <|-- AssertionCall : C -> ActCall
+ Decorator <|-- RetryCall
+ Decorator <|-- EnsuredCall
+ Call <|-- ActCall
+ ActCall "1" --> "1" Act: "target"
+ Decorator "1" --> "1" Call: "target"
+
+ namespace Acts {
+ class Act {
+ perform()
+ }
+ class PageAct
+ class MiscAct
+ }
+ Act <|-- PageAct
+ Act <|-- MiscAct
+
+ namespace ActionUnit {
+ class Action {
+ <>
+ }
+ class Leaf {
+ }
+ class Retry {
+ }
+ class Misc {
+ }
+ }
+ Action <|-- Leaf
+ Action <|-- Retry
+ Action <|-- Misc
+
+ SceneCall "1" --> "1" Scene: "target"
+ Scene "1" *--> "*" Call: "children"
+ ActionComposer ..> Call: "toAction"
+ Call ..> Action: "create"
+```
+
+In the concepts of the **InsDog** framework, a test consists of two elements.
+**Scenes** and **Acts**.
+
+A **Scene** is a composite structure of **Acts**.
+
+**Act** can be implemented by a test programmer, typically **SDET-FW**, to model a reusable real world action such as **Click**, **Navigate**, **Screenshot**, etc.
+
+A **Scene** is a unit that the framework manipulates and executes.
+A user programmer is expected to build a *Scene* to the execution framework in a way which it can recognize.
+A ''call'' is defined for an action such as ''leaf'', ''assertion'', ''sequential'', ''retry'', and so on.
+An **Act** is a unit of a behavior, that user programmers can define as a Java code directly, and from which they build a scene.
+**Calls** are classes to model an internal structure through which an **Action** (**actionunit**) tree is built.
+It is held by `Scene.Builder` and translated into an action tree by **ActionComposer**.
+
+''**ActionComposer**'' and ''**Calls**'' consists a ''**Visitor**'' pattern.
+A call is an 'element' in **Visitor** pattern.
+''**ActionComposer**'' traverses ''**Calls**'' one by one and creates action tree to be executed.
+
+## Data Storage Structure
+
+A variable store is one form of a variable.
+For clarity's sake, we introduce a "simple variable" to distinguish them without confusion.
+
+
+```mermaid
+classDiagram
+ namespace visitor {
+ class ActionComposer {
+ <>
+ }
+ }
+ namespace nodes {
+ class Call {
+ List~String~ inputFieldNames()
+ Action toAction(ActionComposer actionComposer, Map~String, Function~ assignmentResolvers)*
+ }
+ class ActCall {
+ Action toAction(...)
+ }
+ class TargetingCall["DecoratedCall"] {
+ Call target
+ Call target()
+ }
+ class SceneCall {
+ final String inputStoreName
+ final String outputStoreName
+ inputStoreName()
+ workStoreName()
+ outputStoreName()
+ Action toAction(...)
+ }
+ class RetryCall {
+ Action toAction(...)
+ }
+ class AssertionCall {
+ Action toAction(...)
+ }
+ class EnsuredCall {
+ Action toAction(...)
+ }
+ class VariableStore {
+ final Map~String,Object~ store
+ V lookUp(String variableName)
+ void store(String variableName, Object value)
+ void remove(String variableName)
+ }
+ }
+ namespace reusableUnits {
+ class Scene {
+ List~Call~ children()
+ }
+ class Act {
+ void perform(...)
+ }
+ }
+ namespace products {
+ class LeafAction
+ class SequentialAction
+ class AssertionActions
+ class RetryAction
+ }
+
+ Call <|-- ActCall
+ ActCall "1" *--> "1" Act
+ ActCall ..> ActionComposer
+
+ Call <|-- TargetingCall
+ TargetingCall "1" *--> "1" Call
+ TargetingCall <|-- RetryCall
+ TargetingCall <|-- AssertionCall
+ TargetingCall <|-- EnsuredCall
+ EnsuredCall ..> ActionComposer
+ AssertionCall ..> ActionComposer
+ RetryCall ..> ActionComposer
+
+ Call <|-- SceneCall
+ Scene "1" --> "*" Call
+ SceneCall *--> "1" Scene
+ SceneCall ..> ActionComposer
+ SceneCall "1" --> "variableStore" VariableStore
+
+ ActionComposer ..> LeafAction
+ ActionComposer ..> AssertionActions
+ ActionComposer ..> RetryAction
+ ActionComposer ..> SequentialAction
+
+ LeafAction *--> Act
+
+ class SceneBuilder["Scene.Builder"] {
+ build() Scene
+ }
+ Scene <.. SceneBuilder
+```
+
+## Variable Management of Scenes and Acts
+
+A scene and its acts have inputs and outputs.
+Those variables are stored in a map, which is then a variable in a "context" of **actionunit**.
+This map is called "variable-store" in this document.
+
+**Scenes** and **Acts** interacts with each others through those variables in variable-spaces.
+Dependencies between **Scenes** are described by annotations defined in user programs.
+Following is an example that illustrates such interactions.
+
+```java
+import jp.co.moneyforward.autotest.framework.annotations.AutotestExecution;
+import jp.co.moneyforward.autotest.framework.annotations.Export;
+import jp.co.moneyforward.autotest.framework.annotations.Named;
+
+@AutotestExecution("ongoingScene")
+class ExampleAccessingModel {
+ @Named
+ @Export({"a", "b"})
+ Scene scene1() {
+ return someScene();
+ }
+
+ @Named
+ @Export({"x", "y"})
+ Scene scene2() {
+ return someOtherScene();
+ }
+
+ @Named
+ @DependsOn({"scene1", "scene2"})
+ Scene ongoingScene() {
+ return sceneForSomething();
+ }
+}
+```
+
+In this example, `ongoingScene` is designated as a method to create a scene to be executed as a test.
+Since it `@DependsOn` `scene1` and `scene2`, the framework executes them, first.
+As `scene1` `@Export`s `a` and `b`, they are stored in a variable-space of `scene1`.
+Similarly, `x` and `y` are stored in `scene2`'s variable-space.
+
+All those variables are copied into "Working variable-space", where a scene created by `ongoingScene` method is performed.
+It may read and write variables in the space.
+After the execution is finished, all the variables will be copied to its dedicated variable-space for `ongoingScene`.
+
+**NOTE:** Instead of `@DependsOn`, you can use `@When`.
+They are basically the same in terms of description capability of dependencies, just different in how they are executed.
+Please check respective documentations for the differences.
+
+Following is a diagram that illustrates this mechanism:
+
+```mermaid
+graph LR
+ classDef procedure fill:#ffc0c0,color:#222222;
+ classDef dataset fill:#c0c0ff,color:#222222;
+ classDef note fill:#e0e040,stroke:808000,stroke-width:0px,color:#222222;
+
+Fw1(Framework)-->|read|Scene1Dataset
+Fw1(Framework)-->|read|Scene2Dataset
+
+Fw1(Framework)-.->|write|Workarea
+
+OngoingScene(OngoingScene)-->|read|Workarea
+OngoingScene(OngoingScene)-.->|write|Workarea
+
+Fw2(Framework)-->|read|Workarea
+Fw2(Framework)-.->|write|OngoingSceneDataset
+
+NoteFw1[This step is executed by the framework before ''OngoingScene'' is performed.
+It copies variables from output of Scene1 and Scene2 into ''Workarea'' dataset.
+] -.- Fw1
+NoteOngoingScene[A scene only interacts with data in ''workarea'', which are copied from dependency scenes.] -.- OngoingScene
+NoteFw2[This step is executed by the framework after ''OngoingScene'' is performed.
+It copies variables from the ``Workarea` to ''OngoingScene'' dataset.
+] -.- Fw2
+
+class Framework procedure;
+class Workarea,Scene1Dataset,Scene2Dataset,OngoingSceneDataset dataset;
+class NoteFw1,NoteOngoingScene,NoteFw2 note;
+```
+
+Note that an **Act** can have only one input and one output, while a scene has a set of such input and output variables (variable-space).
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/AutotestExecution.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/AutotestExecution.java
new file mode 100644
index 0000000..8253883
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/AutotestExecution.java
@@ -0,0 +1,254 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import com.github.valid8j.fluent.Expectations;
+import jp.co.moneyforward.autotest.framework.cli.CliBase;
+import jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment;
+import jp.co.moneyforward.autotest.framework.testengine.AutotestEngine;
+import jp.co.moneyforward.autotest.framework.testengine.AutotestEngine.ExecutionPlan;
+import jp.co.moneyforward.autotest.framework.testengine.PlanningStrategy;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.util.*;
+
+import static com.github.valid8j.fluent.Expectations.require;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+import static java.util.Arrays.asList;
+import static jp.co.moneyforward.autotest.framework.testengine.PlanningStrategy.DEPENDENCY_BASED;
+import static jp.co.moneyforward.autotest.framework.testengine.PlanningStrategy.PASSTHROUGH;
+
+///
+/// An annotation to let JUnit5 know the class to which this is attached is a test class to be executed by `AutotestEngine`
+/// extension.
+///
+@Retention(RUNTIME)
+@ExtendWith(AutotestEngine.class)
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public @interface AutotestExecution {
+
+ ///
+ /// Specifies a class for loading a {@link Spec} instance.
+ ///
+ /// @return A loader class.
+ /// @see Spec.Loader
+ ///
+ Class executionSpecLoaderClass() default Spec.Loader.Default.class;
+
+ ///
+ /// Specifies how to execute a test class to which this annotation is attached by default.
+ ///
+ /// @return An instance that specifies how to execute the test class.
+ /// @see Spec
+ ///
+ Spec defaultExecution() default @Spec;
+
+ ///
+ /// For each attribute in this annotation interface, user can specify names of `public`, `static`, and `@Named` methods that
+ /// return `Scene` instance in the test class.
+ ///
+ /// This interface models the execution requirement made by a tester.
+ /// Based on the information that this interface provides, the framework will create a plan, which is modeled by `ExecutionPlan`.
+ ///
+ /// @see ExecutionPlan
+ /// @see Named
+ ///
+ @interface Spec {
+ ///
+ /// Returns names of methods to be executed in `@BeforeAll` phase.
+ ///
+ /// @return Names of methods to be executed in `@BeforeAll` phase.
+ ///
+ String[] beforeAll() default {};
+
+ ///
+ /// Returns names of methods to be executed in `@BeforEach` phase.
+ ///
+ /// @return Names of methods to be executed in `@BeforeEach` phase.
+ ///
+ String[] beforeEach() default {};
+
+ ///
+ /// Returns names of methods to be executed in `@Test` phase.
+ ///
+ /// @return Names of methods to be executed in `@Test` phase.
+ ///
+ String[] value() default {};
+
+ ///
+ /// Returns names of methods to be executed in `@AfterEach` phase.
+ ///
+ /// @return Names of methods to be executed in `@AfterEach` phase.
+ ///
+ String[] afterEach() default {};
+
+ ///
+ /// Returns names of methods to be executed in `@AfterAll` phase.
+ ///
+ /// @return Names of methods to be executed in `@AfterAll` phase.
+ ///
+ String[] afterAll() default {};
+
+ ///
+ /// Resolves the dependencies automatically.
+ ///
+ /// If enabled, scenes depended on by scenes specified in `value` are automatically included in `beforeAll` at execution.
+ ///
+ /// Note that, scenes depended on by ones in `value` but depending on another in `value` will be included in `value` not in `beforeAll` at execution.
+ ///
+ /// @return `PASSTHROUGH` execute actions as specified / `DEPENDENCY_BASED_DEFAULT` execute actions based on dependency.
+ /// @see PlanningStrategy
+ ///
+ PlanningStrategy planExecutionWith() default PASSTHROUGH;
+
+ ///
+ /// An interface to be implemented by custom loader class for {@link Spec} instance.
+ /// An implementation of this interface must have a public constructor without parameter to be used as
+ /// {@link AutotestExecution#executionSpecLoaderClass()}.
+ ///
+ interface Loader {
+ ///
+ /// Loads an instance of {@link Spec}.
+ ///
+ /// @param base A base `Spec` instance on which an implementation of this method loads execution spec.
+ /// @param properties A property object from which execution configuration is created.
+ /// @see Default
+ ///
+ Spec load(Spec base, Properties properties);
+
+ ///
+ /// This implementation of {@link Loader} reads the system property {@code jp.co.moneyforward.autotest.scenes} and creates a
+ /// {@link Spec} instance based on the value.
+ /// The syntax of the property value (`PROPERTY_VALUE`) is as follows:
+ ///
+ /// ```
+ /// PROPERTY_VALUE ::= inline:KEY=(VALUE(,VALUE)*)?(;KEY=(VALUE(,VALUE)*)*)?
+ /// KEY ::= 'beforeAll'|'beforeEach'|'tests'|'afterEach'|'afterAll'
+ /// VALUE ::= a defined name of a scene method.
+ /// ```
+ ///
+ /// @see CliBase
+ ///
+ class Default implements Loader {
+ ///
+ /// Returns a new {@code Spec} instance based on the specification discussed in {@link Default}.
+ ///
+ /// @param base A base `Spec` instance on which an implementation of this method loads execution spec.
+ /// @param properties A property object with which base `Spec` is overridden.
+ /// @return A new {@link Spec} object.
+ ///
+ @Override
+ public Spec load(Spec base, Properties properties) {
+ return parseProperties(properties, base);
+ }
+
+ private static Spec parseProperties(Properties properties, Spec base) {
+ Optional resolveDependencies = parseResolveDependenciesProperty(properties);
+ Map> customScenesMap = parseScenesProperty(properties);
+ return new Spec() {
+
+ @Override
+ public Class annotationType() {
+ return Spec.class;
+ }
+
+ @Override
+ public String[] beforeAll() {
+ String stageName = "beforeAll";
+ return customScenesMap.containsKey(stageName) ? customScenesMap.get(stageName).toArray(new String[0])
+ : base.beforeAll();
+ }
+
+ @Override
+ public String[] beforeEach() {
+ String stageName = "beforeEach";
+ return customScenesMap.containsKey(stageName) ? customScenesMap.get(stageName).toArray(new String[0])
+ : base.beforeEach();
+ }
+
+ @Override
+ public String[] value() {
+ String stageName = "value";
+ return customScenesMap.containsKey(stageName) ? customScenesMap.get(stageName).toArray(new String[0])
+ : base.value();
+ }
+
+ @Override
+ public String[] afterEach() {
+ String stageName = "afterEach";
+ return customScenesMap.containsKey(stageName) ? customScenesMap.get(stageName).toArray(new String[0])
+ : base.afterEach();
+ }
+
+ @Override
+ public String[] afterAll() {
+ String stageName = "afterAll";
+ return customScenesMap.containsKey(stageName) ? customScenesMap.get(stageName).toArray(new String[0])
+ : base.afterAll();
+ }
+
+ @Override
+ public PlanningStrategy planExecutionWith() {
+ return resolveDependencies.orElse(base.planExecutionWith());
+ }
+ };
+ }
+
+ private static Optional parseResolveDependenciesProperty(Properties properties) {
+ String propertyKeyForResolveDependencies = "jp.co.moneyforward.autotest.resolveDependencies";
+ if (!properties.containsKey(propertyKeyForResolveDependencies)) {
+ return Optional.empty();
+ }
+ return Optional.of(Boolean.parseBoolean(properties.getProperty(propertyKeyForResolveDependencies)) ? DEPENDENCY_BASED
+ : PASSTHROUGH);
+ }
+
+ private static Map> parseScenesProperty(Properties properties) {
+ String propertyKey = "jp.co.moneyforward.autotest.scenes";
+ if (!properties.containsKey(propertyKey))
+ return Map.of();
+ Set knownStageNames = Set.of("beforeAll", "beforeEach", "value", "afterEach", "afterAll");
+ String value = properties.getProperty(propertyKey);
+ String body = require(Expectations.value(value).toBe().startingWith("inline:")).substring("inline:".length());
+
+ String[] entries = body.split(";");
+ Map> parsed = new HashMap<>();
+ List errors = new ArrayList<>();
+ for (String entry : entries) {
+ if (!entry.contains("=")) {
+ errors.add("An entry must contain a '=': " + entry.substring(0, Math.min(40, entry.length())));
+ continue;
+ }
+ String[] keyAndValues = entry.split("=");
+ String key = keyAndValues[0];
+ String[] values;
+ if (keyAndValues.length >= 2) {
+ values = keyAndValues[1].split(",");
+ } else {
+ values = new String[0];
+ }
+ if (knownStageNames.contains(key)) {
+ parsed.put(key, asList(values));
+ } else {
+ errors.add("Unknown stage name: " + key);
+ }
+ }
+ if (!errors.isEmpty())
+ throw new IllegalArgumentException(composeErrorMessage(errors, propertyKey, value));
+ return parsed;
+ }
+
+ private static String composeErrorMessage(List errors, String propertyKey, String propertyValue) {
+ StringBuilder b = new StringBuilder(String.format("Errors are detected in system property: %s%n", propertyKey));
+ for (String error : errors) {
+ b.append(String.format("- %s%n", error));
+ }
+ b.append(String.format("%n"));
+ b.append(String.format("Property value: %s%n", propertyValue));
+ return b.toString();
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/ClosedBy.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/ClosedBy.java
new file mode 100644
index 0000000..69d8356
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/ClosedBy.java
@@ -0,0 +1,26 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import jp.co.moneyforward.autotest.framework.testengine.PlanningStrategy;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+///
+/// An annotation to let the framework know an access-model method should be closed by an action specified by the method name.
+/// This annotation should be attached to methods for "arrangement" phase, not for "act" (test) methods.
+///
+/// This annotation is activated only when the `PlanningStrategy#DEPENDENCY_BASED` is activated and usually attached to methods for test results checking.
+///
+/// @see PlanningStrategy#DEPENDENCY_BASED
+///
+@Retention(RUNTIME)
+public @interface ClosedBy {
+ ///
+ /// A name of a method that returns an action, which closes an action returned by the annotated method.
+ ///
+ /// @return A name of a closer method.
+ /// @see Named
+ ///
+ String value();
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/DependsOn.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/DependsOn.java
new file mode 100644
index 0000000..13cd11a
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/DependsOn.java
@@ -0,0 +1,32 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import jp.co.moneyforward.autotest.framework.testengine.PlanningStrategy;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+///
+/// An annotation to define a dependency of a method to which this is attached.
+///
+/// This annotation is read by the framework only when the `PlanningStrategy#DEPENDENCY_BASED` is activated and usually attached to methods for performing action to be verified.
+///
+/// This and `@When` annotations are used mutually exclusively.
+///
+/// @see When
+/// @see PlanningStrategy#DEPENDENCY_BASED
+///
+@Retention(RUNTIME)
+@Target(METHOD)
+public @interface DependsOn {
+ ///
+ /// Returns names of scenes on which attached scene method is depending.
+ ///
+ /// @return Names of scenes on which attached scene method is depending.
+ ///
+ /// @see Named
+ ///
+ String[] value() default {};
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/Export.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/Export.java
new file mode 100644
index 0000000..a3adb42
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/Export.java
@@ -0,0 +1,41 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import jp.co.moneyforward.autotest.framework.action.Scene;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+///
+/// // @formatter:off
+/// An annotation to specify the fields that can be used by other scenes.
+///
+/// ```java
+/// @Named
+/// @Export
+/// public Scene aMethod() {
+/// return Scene.perform()
+/// .acts()
+/// .object();
+/// }
+///
+/// @Named
+/// @DependsOn("aMethod")
+/// public Scene bMethod() {
+/// return ...;
+/// }
+/// ```
+///
+/// The method with this annotation can be referenced by other method (`bMethod`) using `@DependsOn` annotation.
+/// The scene in the referencing method can access fields written by a scene in referenced method (`aMethod`).
+/// // @formatter:on
+///
+@Retention(RUNTIME)
+public @interface Export {
+ ///
+ /// Variable names to be exported from the scene returned by the method this annotation is attached to.
+ ///
+ /// @return Exported variable names.
+ ///
+ String[] value() default {Scene.DEFAULT_DEFAULT_VARIABLE_NAME};
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/Named.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/Named.java
new file mode 100644
index 0000000..9f75839
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/Named.java
@@ -0,0 +1,27 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+///
+/// An annotation that specifies a name to specify a method in a test class.
+///
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Named {
+ ///
+ /// A default value.
+ ///
+ /// The name of the annotated method is recognized using the method name itself.
+ /// The signature will not be taken into account.
+ /// To avoid ambiguity, specify the name explicitly.
+ ///
+ String DEFAULT_VALUE = "";
+
+ ///
+ /// Should return a name to specify a method this annotation is attached to.
+ /// If the value is a string without length, the name of the method (`Method#getName()`) itself will be used for it.
+ ///
+ /// @return A name of a method this annotation is attached to.
+ ///
+ String value() default DEFAULT_VALUE;
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/PreparedBy.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/PreparedBy.java
new file mode 100644
index 0000000..7194073
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/PreparedBy.java
@@ -0,0 +1,27 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import jp.co.moneyforward.autotest.framework.action.EnsuredCall;
+
+import java.lang.annotation.*;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+///
+/// An annotation to declare a procedure to ensure the state defined by the target method is satisfied.
+///
+/// @see EnsuredCall
+///
+@Repeatable(PreparedBys.class)
+@Target(METHOD)
+@Retention(RUNTIME)
+public @interface PreparedBy {
+ ///
+ /// Returns a sequence of scene names, by which the target state is satisfied.
+ /// They are executed sequentially in an order this method returns, then target scene call will be performed
+ /// in order to check if the desired state is really satisfied.
+ ///
+ /// @return A sequence of scene names.
+ ///
+ String[] value() default {};
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/PreparedBys.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/PreparedBys.java
new file mode 100644
index 0000000..d5be71a
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/PreparedBys.java
@@ -0,0 +1,24 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+///
+/// A container annotation for `@PreparedBy`.
+/// Not to be used by programmers directly.
+///
+/// @see PreparedBy
+///
+@Target(METHOD)
+@Retention(RUNTIME)
+public @interface PreparedBys {
+ ///
+ /// Child elements.
+ ///
+ /// @return Child annotations.
+ ///
+ PreparedBy[] value();
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/When.java b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/When.java
new file mode 100644
index 0000000..7f6914b
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/When.java
@@ -0,0 +1,58 @@
+package jp.co.moneyforward.autotest.framework.annotations;
+
+import jp.co.moneyforward.autotest.framework.testengine.PlanningStrategy;
+
+import java.lang.annotation.Retention;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+///
+/// A test dependency controlling annotation.
+///
+/// This annotation is read by the framework only when the `PlanningStrategy#DEPENDENCY_BASED` is activated and usually attached to methods for test results checking.
+/// This annotation can be attached to an action method (a `Scene` returning method).
+///
+/// Even if the method to which this annotation is attached is not included in the explicit test scenario, it will be
+/// executed as long as its target method (specified by `value()` attribute of this annotation) is a part of the main test scenario.
+///
+/// The scene created by the attached method will be executed right after the target method.
+///
+/// if there are following methods:
+///
+/// ````java
+///
+/// @Named
+/// @DependsOn("login")
+/// Scene targetMethod() {
+/// return scene;
+/// }
+///
+/// @Named
+/// @When("targetMethod")
+/// Scene checkMethod() {
+/// return scene;
+/// }
+/// ````
+///
+/// And in case only `targetMethod` is specified as a part of the main test scenario, the `checkMethod` will still be executed
+/// right after `targetMethod`.
+/// The same dependency declaration as the `targetMethod` will be used for the `checkMethod`, too.
+///
+/// Even if the target method is executed because it is depended on by others during the **beforeAll** step, the `@When` annotated method won't be executed.
+/// This behavior is useful when a programmer wants to focus on a specific part of a test and save time.
+/// In other words, the scenes from `@When` annotated methods are optional and controlled by the framework.
+///
+/// This and `@DependsOn` annotations are used mutually exclusively.
+///
+/// @see DependsOn
+/// @see PlanningStrategy#DEPENDENCY_BASED
+///
+@Retention(RUNTIME)
+public @interface When {
+ ///
+ /// Specifies scene names, for which the scene method references.
+ ///
+ /// @return A name of a scene.
+ ///
+ String[] value();
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/annotations/package-info.md b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/package-info.md
new file mode 100644
index 0000000..e93e2af
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/annotations/package-info.md
@@ -0,0 +1,36 @@
+This package hols annotations defined by the **InsDog** framework.
+
+## `@AutotestExecution`: Test Class's Fallback Behaviors
+
+This annotation specifies the fallback (default) behaviors of your test class.
+The behavior can be overridden through CLI parameters.
+
+**NOTE:** Currently, there is no way to override the default behavior from higher level.
+You need to modify the code directly and re-compile it for now.
+
+## `@Named`: Identity
+
+This annotation specifies a name of an entity, typically a **Scene** providing method.
+In case, you don't give a `value` of it, the framework considers the name of the entity, i.e. a name of the method if it is a method, is the name of it.
+
+Note that only with the name, the **InsDog** framework-core identifies an entity.
+Meaning that if you don't give this annotation, it simply doesn't recognize a method you create at all.
+
+**NOTE:** Currently, the framework doesn't do validations on your class at all.
+Be careful.
+
+## `@Export`: Exporting Variables for Other Scenes
+
+This annotation can be attached to a **Scene** providing method.
+Its value specifies the variable names that can be used by other **Scene** providing methods, which depend on the attached **Scene** providing method.
+
+## `@DependsOn`, `@When`, and `@ClosedBy`
+
+If you choose a `PlanningSteatedy.DEPENDENCY_BASED` for `@AutotextExecution.Spec#planExecutionWith`, the **InsDog** framework respects the annotations `@DependsOn`, `@When`, and `@ClosedBy` attached to the **Scene** providing methods.
+
+For more details of their semantics, check respective documents of annotations and the `PlanningStrategy`.
+
+## References
+
+@see jp.co.moneyforward.autotest.framework.testengine.PlanningStrategy
+
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/cli/ClassFinder.java b/src/main/java/jp/co/moneyforward/autotest/framework/cli/ClassFinder.java
new file mode 100644
index 0000000..2e0d737
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/cli/ClassFinder.java
@@ -0,0 +1,154 @@
+package jp.co.moneyforward.autotest.framework.cli;
+
+import com.github.valid8j.pcond.forms.Predicates;
+import com.github.valid8j.pcond.forms.Printables;
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.ScanResult;
+import jp.co.moneyforward.autotest.framework.utils.Valid8JCliches;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Tags;
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import static com.github.valid8j.pcond.forms.Predicates.containsString;
+import static com.github.valid8j.pcond.forms.Predicates.isEqualTo;
+import static com.github.valid8j.pcond.forms.Printables.function;
+
+///
+/// An interface to find classes on the class-path.
+///
+public interface ClassFinder {
+ ///
+ /// Returns a stream of classes on the class-path, each of which matches the `query`.
+ ///
+ /// @param query A query to check if a given class matches.
+ ///
+ /// @return A stream of matching classes.
+ ///
+ Stream> findMatchingClasses(Predicate> query);
+
+ ///
+ /// Returns a `ClassFinder`, which checks all the classes under `rootPackage` with a given `query` predicate.
+ ///
+ /// @param rootPackage A root package.
+ /// @return A new `ClassFinder` object.
+ ///
+ static ClassFinder create(String rootPackage) {
+ return query -> {
+ //NOSONAR
+ try (ScanResult result = new ClassGraph().enableClassInfo()
+ .enableAnnotationInfo()
+ .acceptPackages(rootPackage)
+ .scan()) {
+
+ return result.getAllClasses()
+ .stream()
+ .map(ClassInfo::loadClass)
+ .filter(query)
+ .toList()
+ .stream()
+ .map(c -> (Class) c);
+ }
+ };
+ }
+
+ ///
+ /// A utility method to return a `Predicate`, which can be used with `findMatchingClasses` method.
+ ///
+ /// @param value A string value from which the returned predicate is created.
+ /// @return A predicate which matches a class whose name is equal to `value`.
+ ///
+ static Predicate> classNameIsEqualTo(String value) {
+ return Valid8JCliches.Transform.$(functionSimpleName())
+ .check(isEqualTo(value));
+ }
+
+ ///
+ /// A utility method to return a `Predicate`, which can be used with `findMatchingClasses` method.
+ ///
+ /// @param value A string value from which the returned predicate is created.
+ /// @return A predicate which matches a class whose name is containing `value`.
+ ///
+ static Predicate> classNameContaining(String value) {
+ return Valid8JCliches.Transform.$(functionSimpleName())
+ .check(containsString(value));
+ }
+
+ ///
+ /// A utility method to return a `Predicate`, which can be used with `findMatchingClasses` method.
+ ///
+ /// @param value A string value from which the returned predicate is created.
+ /// @return A predicate which matches a class whose name matches a regular expression `value`.
+ ///
+ static Predicate> classNameMatchesRegex(String value) {
+ return Valid8JCliches.Transform.$(functionSimpleName())
+ .check(Predicates.matchesRegex(value));
+ }
+
+ ///
+ /// A utility method to return a `Predicate`, which can be used with `findMatchingClasses` method.
+ ///
+ /// @return A predicate which matches any class.
+ ///
+ static Predicate> alwaysTrue() {
+ return Predicates.alwaysTrue();
+ }
+
+ ///
+ /// A utility method to return a `Predicate`, which can be used with `findMatchingClasses` method.
+ ///
+ /// @param klass A class object from which the returned predicate is created.
+ /// @return A predicate which matches a class which is assignable from `klass`.
+ ///
+ static Predicate> isAssignableTo(Class klass) {
+ return Printables.predicate("isAssignableTo[" + klass.getSimpleName() + "]",
+ klass::isAssignableFrom);
+ }
+
+ ///
+ /// A utility method to return a `Predicate`, which can be used with `findMatchingClasses` method.
+ ///
+ /// @param annotationClasses classes from which the returned predicate is created.
+ /// @return A predicate which matches any of `annotationClasses` is present.
+ ///
+ @SafeVarargs
+ static Predicate> hasAnnotations(Class... annotationClasses) {
+ return Printables.predicate("hasAnnotation" + Arrays.stream(annotationClasses).map(c -> "@" + c.getSimpleName()).toList(),
+ (Class c) -> Arrays.stream(annotationClasses).anyMatch(c::isAnnotationPresent));
+ }
+
+ ///
+ /// A utility method to return a `Predicate`, which can be used with `findMatchingClasses` method.
+ ///
+ /// @param value A string value from which the returned predicate is created.
+ /// @return A predicate which matches a class whose `@Tag` annotation value is equal to `value`.
+ ///
+ static Predicate> hasTagValueEqualTo(String value) {
+ return hasTagMatching(Printables.predicate("valueEqualTo[" + value + "]", t -> Objects.equals(t.value(), value)));
+ }
+
+ private static Predicate> hasTagMatching(Predicate predicate) {
+ return Printables.predicate("hasTagMatching[" + predicate + "]",
+ aClass -> aClass.isAnnotationPresent(Tag.class) && predicate.test(aClass.getAnnotation(Tag.class)) ||
+ aClass.isAnnotationPresent(Tags.class) && Arrays.stream(aClass.getAnnotation(Tags.class).value())
+ .anyMatch(predicate));
+ }
+
+ static Predicate> hasTagValueContaining(String value) {
+ return hasTagMatching(Printables.predicate("valueContaining[" + value + "]", t -> t.value().contains(value)));
+ }
+
+ static Predicate> hasTagValueMatchesRegex(String value) {
+ return hasTagMatching(Printables.predicate("valueMatchingRegex[" + value + "]", t -> t.value().matches(value)));
+ }
+
+ static Function, String> functionSimpleName() {
+ return function("simpleName", Class::getSimpleName);
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/cli/CliBase.java b/src/main/java/jp/co/moneyforward/autotest/framework/cli/CliBase.java
new file mode 100644
index 0000000..4e24f85
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/cli/CliBase.java
@@ -0,0 +1,198 @@
+package jp.co.moneyforward.autotest.framework.cli;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import picocli.CommandLine;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+
+import java.io.PrintStream;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+///
+/// A base class of CLI for **insdog**.
+///
+public abstract class CliBase implements Callable {
+ private static final Logger LOGGER = LoggerFactory.getLogger(CliBase.class);
+
+ protected abstract String rootPackageName();
+
+ @CommandLine.Parameters(index = "0..*", description = "Subcommands of this CLI.")
+ private List subcommands;
+
+ @Option(
+ names = {"-q", "--query"},
+ description = """
+ Specifies a query. If multiple options are given, they will be treated as disjunctions.
+
+ QUERY ::= QUERY_TERM
+ QUERY_TERM ::= ATTR ':' OP COND
+ ATTR ::= ('classname'|'tag')
+ OP ::= ('=' | '~' | '%')
+ COND ::= ('*'|CLASS_NAME|TAG_NAME)
+ CLASS_NAME ::= {Java-wise valid character sequence for a class name}
+ TAG_NAME ::= (Any string)
+
+ This should be used with run, list-testclasses, and list-tags subcommands.
+
+ NOTE:
+ '=' (OP): Exact match
+ '~' (OP): Regular expression match
+ '%' (OP): Partial match
+ """,
+ defaultValue = "classname:~.*")
+ private String[] queries;
+
+ ///
+ /// @see jp.co.moneyforward.autotest.framework.annotations.AutotestExecution.Spec.Loader
+ ///
+ @Option(names = {"--execution-descriptor"},
+ description = """
+ Used with 'run' subcommand.
+ An execution descriptor is a JSON and it should look like following:
+
+ - --execution-descriptor=beforeAll=open;value=login,connectBank,disconnectBank,logout;afterEach:screenshot,afterAll:close
+
+ This option can be specified multiple times.
+ If there are more than one, they are merged by concatenating the elements.
+ For instance, you can do:
+
+ --execution-descriptor=beforeAll=open
+ --execution-descriptor=value=login,connectBank,disconnectBank,logout
+ --execution-descriptor=afterEach:screenshot
+ --execution-descriptor=afterAll=close
+
+ Instead of the example shown above.
+ This option is advised to be used with `-q` option to ensure that tests to be run share the same accessing model.
+ """)
+ private String[] executionDescriptor = new String[]{};
+
+ @Option(names = {"--execution-profile"},
+ description = """
+ Used with 'run' subcommand.
+
+ Specifies an execution profile, with which you can override a test's execution time parameters such as: user email, password, etc.
+
+ For instance, you can do:
+
+ --execution-profile=userEmail:user@example.com
+ --execution-profile=password:password
+ --execution-profile=domain:{SUT_DOMAIN_NAME}
+
+ For the part after '=' and before ':', you can specify a method name that returns a 'String' in ExecutionProfile.
+ """)
+ private String[] executionProfile = new String[]{};
+
+
+ @Command(name = "run",
+ description = {"""
+ Runs tests matching with any of -q, --query options.
+
+ Even if one test matches with multiple -q, -query options, it will be executed only once.
+ """})
+ public Integer run() {
+ int ret;
+ try {
+ int numFailed = CliUtils.runTests(this.rootPackageName(), this.queries, this.executionDescriptor, this.executionProfile);
+ ret = numFailed == 0 ? 0
+ : 1;
+ } catch (IllegalArgumentException e) {
+ ret = 2;
+ }
+ return ret;
+ }
+
+ @Command(
+ name = "list-testclasses",
+ description = """
+ Prints all known tests.
+ A in the result can be used in a "classname:" given to -q, --query options
+ """)
+ public Integer listTestClasses() {
+ int ret;
+ //NOSONAR
+ try (var out = out(); var err = err()) {
+ try {
+ CliUtils.listTestClasses(this.queries, this.rootPackageName())
+ .forEach(out::println);
+ ret = 0;
+ } catch (IllegalArgumentException e) {
+ err.println(e.getMessage());
+ ret = 2;
+ }
+ }
+ return ret;
+ }
+
+ @Command(name = "list-tags",
+ description = """
+ Prints all known tags.
+ A in the result can be used in a "tag:" query given to -q, --query= options.
+ """)
+ public Integer listTags() {
+ int ret;
+ //NOSONAR
+ try (var out = out()) {
+ CliUtils.listTags(this.rootPackageName())
+ .forEach(out::println);
+ ret = 0;
+ } catch (IllegalArgumentException e) {
+ LOGGER.error(e.getMessage());
+ ret = 2;
+ }
+ return ret;
+ }
+
+ @Command(
+ name = "list-accessmodels",
+ description = """
+ Prints all known access models.
+ An in the result can be used in a "accessmodel:" query given to -q, --query options.
+
+ NOTE: Not yet implemented!
+ """)
+ public Integer listAccessModels() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Command(
+ name = "show-default-execution-descriptors",
+ description = {"""
+ Show default execution descriptors of tests matching with any of -q, --query options.
+
+ Even if one test matches with multiple -q, -query options, it will be shown only once.
+
+ NOTE: Not yet implemented!
+ """})
+ public Integer showDefaultExecutionDescriptors() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Command(
+ name = "show-default-execution-profile",
+ description = {"""
+ Show default execution profile.
+
+ NOTE: Not yet implemented!
+ """})
+ public Integer showExecutionProfile() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Integer call() throws Exception { // your business logic goes here...
+ try (var err = err()) {
+ err.println("You didn't specify known subcommands, try -h, --help option: " + this.subcommands);
+ return 2;
+ }
+ }
+
+ private static PrintStream out() {
+ return System.out;
+ }
+
+ private static PrintStream err() {
+ return System.err;
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/cli/CliUtils.java b/src/main/java/jp/co/moneyforward/autotest/framework/cli/CliUtils.java
new file mode 100644
index 0000000..148cfcd
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/cli/CliUtils.java
@@ -0,0 +1,276 @@
+package jp.co.moneyforward.autotest.framework.cli;
+
+import com.github.valid8j.pcond.forms.Predicates;
+import jp.co.moneyforward.autotest.framework.annotations.AutotestExecution;
+import jp.co.moneyforward.autotest.framework.testengine.AutotestEngine;
+import jp.co.moneyforward.autotest.framework.utils.InternalUtils;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Tags;
+import org.junit.platform.engine.TestDescriptor;
+import org.junit.platform.engine.TestExecutionResult;
+import org.junit.platform.engine.UniqueId;
+import org.junit.platform.launcher.Launcher;
+import org.junit.platform.launcher.TestIdentifier;
+import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
+import org.junit.platform.launcher.core.LauncherFactory;
+import org.junit.platform.launcher.listeners.SummaryGeneratingListener;
+import org.junit.platform.launcher.listeners.TestExecutionSummary;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+import static com.github.valid8j.classic.Requires.requireNonNull;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toMap;
+import static jp.co.moneyforward.autotest.framework.core.ExecutionEnvironment.testResultDirectoryFor;
+import static jp.co.moneyforward.autotest.framework.utils.InternalUtils.removeFile;
+import static jp.co.moneyforward.autotest.framework.utils.InternalUtils.writeTo;
+import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;
+import static org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder.request;
+
+///
+/// A utility class for **InsDog** CLI.
+///
+public enum CliUtils {
+ ;
+ private static final Logger LOGGER = LoggerFactory.getLogger(CliUtils.class);
+ private static Map profileOverriders;
+
+ static void initialize(String[] profileOverriders) {
+ CliUtils.profileOverriders = Arrays.stream(profileOverriders).collect(toMap(each -> each.substring(each.indexOf('=') + 1, each.indexOf(':')),
+ each -> each.substring(each.indexOf(':') + 1)));
+ }
+
+ public static Map getProfileOverriders() {
+ return profileOverriders;
+ }
+
+ public static List listTags(String rootPackageName) {
+ return ClassFinder.create(rootPackageName)
+ .findMatchingClasses(Predicates.alwaysTrue())
+ .map(c -> (Class) c)
+ .flatMap((Function, Stream>) CliUtils::tagAnnotationsFrom)
+ .map(Tag::value)
+ .distinct()
+ .toList();
+ }
+
+ @SuppressWarnings("unchecked")
+ public static List> listTestClasses(String[] queries1, String rootPackageName) {
+ return ClassFinder.create(rootPackageName)
+ .findMatchingClasses(Predicates.or(Arrays.stream(queries1)
+ .map(CliUtils::parseQuery)
+ .map(p -> p.and(ClassFinder.hasAnnotations(AutotestExecution.class)))
+ .toArray(Predicate[]::new)))
+ .toList();
+ }
+
+ @SuppressWarnings("SwitchStatementWithTooFewBranches")
+ public static Predicate> parseQuery(String query) {
+ requireNonNull(query);
+ Pattern regex = Pattern.compile("(?classname|tag):(?[=~%]?)(?.*)");
+ Matcher matcher = regex.matcher(query);
+ if (!matcher.matches())
+ throw new IllegalArgumentException("A query '" + query + "' didn't match: " + regex);
+ String attr = matcher.group("attr");
+ String opInQuery = matcher.group("op");
+ String op = !Objects.equals(opInQuery, "") ? opInQuery
+ : "(default)";
+ String cond = matcher.group("cond");
+ // We do use switch as the attribute names are planned to be enhanced to provide new features.
+ return switch (attr) {
+ case "classname" -> switch (op) {
+ case "~" -> ClassFinder.classNameMatchesRegex(cond);
+ case "%" -> ClassFinder.classNameContaining(cond);
+ // '=' and 'default' are handled as 'equalTo' operator
+ default -> ClassFinder.classNameIsEqualTo(cond);
+ };
+ // "tag" attribute is handled by this clause.
+ default -> switch (op) {
+ case "~" -> ClassFinder.hasTagValueMatchesRegex(cond);
+ case "%" -> ClassFinder.hasTagValueContaining(cond);
+ // '=' and 'default' are handled as 'equalTo' operator
+ default -> ClassFinder.hasTagValueEqualTo(cond);
+ };
+ };
+ }
+
+ public static Stream tagAnnotationsFrom(Class c) {
+ return Stream.concat(
+ streamTags(c),
+ tagAnnotationsFromParentContainer(c));
+ }
+
+ public static Stream tagAnnotationsFromParentContainer(Class c) {
+ return c.isAnnotationPresent(Tags.class) ? Arrays.stream(c.getAnnotation(Tags.class).value())
+ : Stream.empty();
+ }
+
+ public static Stream streamTags(Class c) {
+ return c.isAnnotationPresent(Tag.class) ? Stream.of(c.getAnnotation(Tag.class))
+ : Stream.empty();
+ }
+
+ public static String composeSceneDescriptorPropertyValue(String[] executionDescriptors) {
+ Map> map = new HashMap<>();
+ for (var each : executionDescriptors) {
+ var e = each.split("=");
+ map.putIfAbsent(e[0], Collections.emptyList());
+ map.computeIfPresent(e[0], (k, v) -> Stream.concat(v.stream(),
+ Stream.of(e[1].split(","))).toList());
+ }
+ return "inline:" + map.entrySet()
+ .stream()
+ .map(e -> String.format("%s=%s", e.getKey(), String.join(",", e.getValue())))
+ .collect(joining(";"));
+ }
+
+ public static int runTests(String rootPackageName, String[] queries, String[] executionDescriptors, String[] executionProfile) {
+ Map, TestExecutionSummary> testReport = runTests(rootPackageName,
+ queries,
+ executionDescriptors,
+ executionProfile,
+ createSummaryGeneratingListener()
+ );
+ return testReport.values()
+ .stream()
+ .map(s -> s.getFailures().size())
+ .reduce(Integer::sum)
+ .orElseThrow(NoSuchElementException::new);
+ }
+
+ public static SummaryGeneratingListener createSummaryGeneratingListener() {
+ return new SummaryGeneratingListener() {
+ long before;
+
+ @Override
+
+ public void executionStarted(TestIdentifier testIdentifier) {
+ if (testIdentifier.isTest() || isTestClass(testIdentifier)) {
+ before = System.currentTimeMillis();
+ File resultFile = resultFileFor(testIdentifier);
+ removeFile(resultFile);
+ writeTo(resultFile, String.format("TYPE: %s%n", testIdentifier.getType()));
+ }
+ super.executionStarted(testIdentifier);
+ }
+
+ @Override
+ public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
+ super.executionFinished(testIdentifier, testExecutionResult);
+ if (testIdentifier.isTest() || isTestClass(testIdentifier)) {
+ File resultFile = resultFileFor(testIdentifier);
+ writeTo(resultFile, String.format("TIME: %d%n", System.currentTimeMillis() - before));
+ writeTo(resultFile, String.format("RESULT: %s%n", testExecutionResult.getStatus()));
+ }
+ }
+
+ private File resultFileFor(TestIdentifier testIdentifier) {
+ return new File(testResultDirectoryFor(testClassNameOf(testIdentifier),
+ testIdentifier.getDisplayName()).toFile(), "RESULT");
+ }
+
+ private String testClassNameOf(TestIdentifier testIdentifier) {
+ return testIdentifier.getUniqueIdObject()
+ .getSegments()
+ .stream()
+ .filter(s -> Objects.equals(s.getType(), "class"))
+ .map(UniqueId.Segment::getValue)
+ .findFirst()
+ .orElse("unknown.TestClass");
+ }
+
+ private boolean isTestClass(TestIdentifier testIdentifier) {
+ return testIdentifier.getType() == TestDescriptor.Type.CONTAINER
+ && testClassNameOf(testIdentifier).endsWith(testIdentifier.getDisplayName());
+ }
+ };
+ }
+
+ @SuppressWarnings({"unchecked", "RedundantCast"})
+ public static Map, TestExecutionSummary> runTests(String rootPackageName,
+ String[] queries,
+ String[] executionDescriptors,
+ String[] executionProfile,
+ SummaryGeneratingListener testExecutionListener) {
+ if (executionDescriptors.length > 0)
+ System.setProperty("jp.co.moneyforward.autotest.scenes", composeSceneDescriptorPropertyValue(executionDescriptors));
+ AutotestEngine.configureLoggingForSessionLevel();
+ initialize(executionProfile);
+ Map, TestExecutionSummary> testReport = new HashMap<>();
+ List> targetTestClasses = new ArrayList<>();
+ Launcher launcher = LauncherFactory.create();
+ LauncherDiscoveryRequestBuilder requestBuilder = request();
+ ClassFinder.create(rootPackageName)
+ .findMatchingClasses(Predicates.or(Arrays.stream(queries)
+ .map(CliUtils::parseQuery)
+ .map(p -> p.and(ClassFinder.hasAnnotations(AutotestExecution.class)))
+ .toArray(Predicate[]::new)))
+ .map(c -> (Class) c)
+ // We need this cast (Classo) to work around a presumable compiler bug in Java 21.
+ .sorted(Comparator.comparing(o -> ((Class) o).getCanonicalName()))
+ .forEach((Consumer>) c -> {
+ requestBuilder.selectors(selectClass(c));
+ targetTestClasses.add(c);
+ });
+ LOGGER.info("Running test classes in {}", rootPackageName);
+ LOGGER.info("----");
+ targetTestClasses.forEach(c -> LOGGER.info("- {}", c.getCanonicalName()));
+ LOGGER.info("----");
+ LOGGER.info("");
+
+ launcher.execute(requestBuilder.build(), testExecutionListener);
+ TestExecutionSummary testExecutionSummary = testExecutionListener.getSummary();
+ testReport.put(CliUtils.class, testExecutionSummary);
+ logExecutionSummary(testExecutionSummary);
+ logFailureSummary(testExecutionSummary);
+ return testReport;
+ }
+
+ private static void logExecutionSummary(TestExecutionSummary testExecutionSummary) {
+ LOGGER.info("----");
+ StringWriter buffer = new StringWriter();
+ testExecutionSummary.printTo(new PrintWriter(buffer));
+ Arrays.stream(buffer.toString()
+ .split("\n"))
+ .map(String::trim)
+ .filter(s -> !s.isEmpty())
+ .forEach(LOGGER::info);
+ LOGGER.info("----");
+ LOGGER.info("");
+ }
+
+ private static void logFailureSummary(TestExecutionSummary testExecutionSummary) {
+ LOGGER.info("Failure summary");
+ LOGGER.info("----");
+ if (testExecutionSummary.getFailures().isEmpty()) LOGGER.info("- (none)");
+ else testExecutionSummary.getFailures()
+ .forEach(f -> LOGGER.info("- {}(in {}): {}",
+ f.getTestIdentifier().getDisplayName(),
+ Optional.ofNullable(segmentsOfExecutionSummary(f).size() >= 2 ? segmentsOfExecutionSummary(f).get(1)
+ : null)
+ .map(UniqueId.Segment::getValue)
+ .orElse("unknown"),
+ InternalUtils.shorten(f.getException()
+ .getMessage()
+ .replace("\n", " "))));
+ LOGGER.info("----");
+ LOGGER.info("");
+ }
+
+ private static List segmentsOfExecutionSummary(TestExecutionSummary.Failure f) {
+ return f.getTestIdentifier()
+ .getUniqueIdObject()
+ .getSegments();
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/core/AutotestException.java b/src/main/java/jp/co/moneyforward/autotest/framework/core/AutotestException.java
new file mode 100644
index 0000000..bd1677f
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/core/AutotestException.java
@@ -0,0 +1,15 @@
+package jp.co.moneyforward.autotest.framework.core;
+
+///
+/// An exception for the **InsDog** framework.
+///
+public class AutotestException extends RuntimeException {
+ ///
+ /// Creates an object of this class.
+ /// @param message A message for this exception.
+ /// @param cause A cause of this exception, if any. Otherwise, `null`.
+ ///
+ public AutotestException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/src/main/java/jp/co/moneyforward/autotest/framework/core/AutotestRunner.java b/src/main/java/jp/co/moneyforward/autotest/framework/core/AutotestRunner.java
new file mode 100644
index 0000000..3818698
--- /dev/null
+++ b/src/main/java/jp/co/moneyforward/autotest/framework/core/AutotestRunner.java
@@ -0,0 +1,153 @@
+package jp.co.moneyforward.autotest.framework.core;
+
+import com.github.dakusui.actionunit.actions.Composite;
+import com.github.dakusui.actionunit.core.Action;
+import com.github.dakusui.actionunit.io.Writer;
+import com.github.dakusui.actionunit.visitors.ActionReporter;
+import com.github.dakusui.actionunit.visitors.ReportingActionPerformer;
+import jp.co.moneyforward.autotest.framework.annotations.AutotestExecution;
+import jp.co.moneyforward.autotest.framework.utils.InternalUtils;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestTemplate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static jp.co.moneyforward.autotest.framework.utils.InternalUtils.composeResultMessageLine;
+
+///
+/// An interface that runs specified actions for stages: `beforeAll`, `beforeEach`, `tests`, `afterEach`, and `afterAll`.
+///
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@AutotestExecution
+public interface AutotestRunner {
+ ///
+ /// A logger to record the activity of this object.
+ ///
+ Logger LOGGER = LoggerFactory.getLogger(AutotestRunner.class);
+
+ ///
+ /// Performs a given `action` for **beforeAll** stage and writes a report of the activity to `writer`
+ ///
+ /// @param action An action to be performed as `beforeAll` stage.
+ /// @param writer A writer through which report of the `action` will be written.
+ ///
+ default void beforeAll(Action action, Writer writer) {
+ performAndReport(this, action, writer);
+ }
+
+ ///
+ /// Performs a given `action` for **beforeEach** stage and writes a report of the activity to `writer`
+ ///
+ /// @param action An action to be performed as `beforeEach` stage.
+ /// @param writer A writer through which report of the `action` will be written.
+ ///
+ default void beforeEach(Action action, Writer writer) {
+ performAndReport(this, action, writer);
+ }
+
+ ///
+ /// A template that defines the overall scenario of a test.
+ ///
+ /// @param name A name of a test.
+ /// @param action An action executed as a test.
+ ///
+ @TestTemplate
+ default void runTestAction(String name, Action action) {
+ var out = new ArrayList();
+ String stageName = "value";
+ boolean succeeded = false;
+ try {
+ Writer writer = createWriter(out);
+ performAndReport(this, action, writer);
+ succeeded = true;
+ } finally {
+ String message = composeResultMessage(this.getClass(), stageName, name, succeeded);
+ LOGGER.info(message);
+ out.forEach(l -> LOGGER.info(composeResultMessageLine(this.getClass(), stageName, l)));
+ }
+ }
+
+ ///
+ /// Performs a given `action` for **afterEach** stage and writes a report of the activity to `writer`
+ ///
+ /// @param action An action to be performed.
+ /// @param writer A writer through which a report is written.
+ ///
+ default void afterEach(Action action, Writer writer) {
+ performAndReport(this, action, writer);
+ }
+
+ ///
+ /// Performs a given `action` for **afterAll** stage and writes a report of the activity to `writer`
+ ///
+ /// @param action An action to be performed.
+ /// @param writer A writer through which a report is written.
+ ///
+ default void afterAll(Action action, Writer writer) {
+ performAndReport(this, action, writer);
+ }
+
+ ///
+ /// Creates a writer through which action activities are reported.
+ ///
+ /// @param out A list to which a copy of the report is appended.
+ /// @return A writer through which action report is written.
+ ///
+ default Writer createWriter(List