Update README.md

Finish offline ID3 support

.circleci/config.yml

@@ -0,0 +1,154 @@
+version: 2.1
+parameters:
+  memory-config:
+      type: string
+      default: "-Xmx3200m -Xms256m -XX:MaxMetaspaceSize=1g"
+  memory-config-debug:
+    type: string
+    default: "-Xmx3200m -Xms256m -XX:MaxMetaspaceSize=1g -verbose:gc -Xlog:gc*"
+jobs:
+  build:
+    docker:
+      - image: cimg/android:2022.06.1
+    working_directory: ~/ultrasonic
+    environment:
+      JVM_OPTS: << pipeline.parameters.memory-config >>
+      JAVA_TOOL_OPTIONS: << pipeline.parameters.memory-config >>
+      GRADLE_OPTS: << pipeline.parameters.memory-config >>
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - v2-ultrasonic-{{ .Branch }}-{{ checksum "gradle/libs.versions.toml" }}
+            - v2-ultrasonic-{{ .Branch }}
+            - v2-ultrasonic
+      - run:
+          name: configure gradle.properties for CI building
+          command: |
+            sed -i '/^org.gradle.jvmargs/d' gradle.properties
+            sed -i 's/^org.gradle.daemon=true/org.gradle.daemon=false/g' gradle.properties
+            cat gradle.properties
+      - run:
+          name: checkstyle
+          command: ./gradlew -Pqc ktlintCheck
+      - run:
+          name: static analysis
+          command: ./gradlew -Pqc detekt
+      - run:
+          name: build debug
+          command: ./gradlew assembleDebug
+      - run:
+          name: unit-tests
+          command: |
+            ./gradlew ciTest testDebugUnitTest
+      - run:
+          name: lint
+          command: ./gradlew :ultrasonic:lintRelease
+      - run:
+          name: build
+          command: ./gradlew buildRelease
+      - run:
+          name: assemble release
+          command: ./gradlew assembleRelease
+      - save_cache:
+          paths:
+            - ~/.gradle
+          key: v2-ultrasonic-{{ .Branch }}-{{ checksum "gradle/libs.versions.toml" }}
+      - store_artifacts:
+          path: ultrasonic/build/reports
+          destination: reports
+      - store_artifacts:
+          path: subsonic-api/build/reports
+          destination: reports
+  push_translations:
+    docker:
+      - image: cimg/python:3.6
+    working_directory: ~/ultrasonic
+    steps:
+      - checkout
+      - run:
+          name: install transifex client
+          command: |
+            python -m venv ~/venv
+            . ~/venv/bin/activate
+            pip install transifex-client
+      - run:
+          name: configure transifex client
+          command: echo $'[https://www.transifex.com]\nhostname = https://www.transifex.com\nusername = api\npassword = '"${TRANSIFEX_PASSWORD}"$'\n' > ~/.transifexrc
+      - run:
+          name: push changes in translation files
+          command: |
+            . ~/venv/bin/activate
+            tx push -s
+  generate_signed_apk:
+    docker:
+      - image: cimg/android:2022.06.1
+    working_directory: ~/ultrasonic
+    environment:
+      JVM_OPTS: << pipeline.parameters.memory-config >>
+      JAVA_TOOL_OPTIONS: << pipeline.parameters.memory-config >>
+      GRADLE_OPTS: << pipeline.parameters.memory-config >>
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - v2-ultrasonic-{{ .Branch }}-{{ checksum "gradle/libs.versions.toml" }}
+            - v2-ultrasonic-{{ .Branch }}
+            - v2-ultrasonic
+      - run:
+          name: decrypt ultrasonic-keystore
+          command: openssl aes-256-cbc -K ${ULTRASONIC_KEYSTORE_KEY} -iv ${ULTRASONIC_KEYSTORE_IV} -in ultrasonic-keystore.enc -out ultrasonic-keystore -d
+      - run:
+          name: build release apk
+          command: ./gradlew build assembleRelease
+      - run:
+          name: sign release apk
+          command: |
+            export PATH="${JAVA_HOME}/bin:${PATH}"
+            mkdir -p /tmp/ultrasonic-release
+            ${ANDROID_HOME}/build-tools/32.0.0/zipalign -v 4 ultrasonic/build/outputs/apk/release/ultrasonic-release-unsigned.apk /tmp/ultrasonic-release/ultrasonic-${CIRCLE_TAG}.apk
+            ${ANDROID_HOME}/build-tools/32.0.0/apksigner sign --verbose --ks ~/ultrasonic/ultrasonic-keystore --ks-pass pass:${ULTRASONIC_KEYSTORE_STOREPASS} --key-pass pass:${ULTRASONIC_KEYSTORE_KEYPASS} /tmp/ultrasonic-release/ultrasonic-${CIRCLE_TAG}.apk
+            ${ANDROID_HOME}/build-tools/32.0.0/apksigner verify --verbose /tmp/ultrasonic-release/ultrasonic-${CIRCLE_TAG}.apk
+      - persist_to_workspace:
+          root: /tmp/ultrasonic-release
+          paths:
+            - ultrasonic-*.apk*
+  publish_github_signed_apk:
+    docker:
+      - image: cimg/go:1.18
+    steps:
+      - attach_workspace:
+          at: /tmp/ultrasonic-release
+      - run:
+          name: install ghr
+          command: go install -v github.com/tcnksm/ghr@latest
+      - run:
+          name: publish release on github tag
+          command: ghr -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} ${CIRCLE_TAG} /tmp/ultrasonic-release
+workflows:
+  version: 2
+  build_and_push_translations:
+    jobs:
+      - build
+      - push_translations:
+          requires:
+            - build
+          filters:
+            branches:
+              only:
+                - develop
+      - generate_signed_apk:
+          filters:
+            tags:
+              only: /^[0-9]+(\.[0-9]+)*(-beta\.[0-9]+)?/
+            branches:
+              ignore: /.*/
+      - publish_github_signed_apk:
+          requires:
+            - generate_signed_apk
+          filters:
+            tags:
+              only: /^[0-9]+(\.[0-9]+)*(-beta\.[0-9]+)?/
+            branches:
+              ignore: /.*/
+

.github/dependabot.yml

@@ -0,0 +1,15 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "gradle" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "monthly"
+    ignore:
+      - dependency-name: "*"
+        update-types: ["version-update:semver-patch"]
+

.gitignore

@@ -1,3 +1,6 @@
+# Release folder
+ultrasonic/release/
+
 # Built application files
 *.apk
 *.ap_
@@ -34,10 +37,8 @@ captures/
 
 # Intellij
 *.iml
-.idea/workspace.xml
-.idea/libraries
-.idea/encodings.xml
-.idea/misc.xml
+.idea/
+
 
 # Keystore files
 *.jks

.idea/.name

@@ -1 +0,0 @@
-ultrasonic

.idea/codeStyles/Project.xml

@@ -0,0 +1,128 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value />
+      </option>
+      <option name="NAME_COUNT_TO_USE_STAR_IMPORT" value="2147483647" />
+      <option name="NAME_COUNT_TO_USE_STAR_IMPORT_FOR_MEMBERS" value="2147483647" />
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </JetCodeStyleSettings>
+    <codeStyleSettings language="XML">
+      <option name="FORCE_REARRANGE_MODE" value="1" />
+      <indentOptions>
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+      </indentOptions>
+      <arrangement>
+        <rules>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:android</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:id</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>style</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>ANDROID_ATTRIBUTE_ORDER</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>.*</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+        </rules>
+      </arrangement>
+    </codeStyleSettings>
+    <codeStyleSettings language="kotlin">
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

.idea/compiler.xml

@@ -1,22 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <resourceExtensions />
-    <wildcardResourcePatterns>
-      <entry name="!?*.java" />
-      <entry name="!?*.form" />
-      <entry name="!?*.class" />
-      <entry name="!?*.groovy" />
-      <entry name="!?*.scala" />
-      <entry name="!?*.flex" />
-      <entry name="!?*.kt" />
-      <entry name="!?*.clj" />
-      <entry name="!?*.aj" />
-    </wildcardResourcePatterns>
-    <annotationProcessing>
-      <profile default="true" name="Default" enabled="false">
-        <processorPath useClasspath="true" />
-      </profile>
-    </annotationProcessing>
+    <bytecodeTargetLevel target="11" />
   </component>
 </project>

.idea/copyright/Default.xml

@@ -0,0 +1,6 @@
+<component name="CopyrightManager">
+  <copyright>
+    <option name="notice" value="&amp;#36;file.fileName&#10;Copyright (C) 2009-&amp;#36;today.year Ultrasonic developers&#10;&#10;Distributed under terms of the GNU GPLv3 license." />
+    <option name="myName" value="Default" />
+  </copyright>
+</component>

.idea/copyright/profiles_settings.xml

@@ -1,3 +1,7 @@
 <component name="CopyrightManager">
-  <settings default="" />
+  <settings default="Default">
+    <LanguageOptions name="Kotlin">
+      <option name="fileTypeOverride" value="3" />
+    </LanguageOptions>
+  </settings>
 </component>

.idea/gradle.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="1.8" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/library" />
-            <option value="$PROJECT_DIR$/menudrawer" />
-            <option value="$PROJECT_DIR$/pulltorefresh" />
-            <option value="$PROJECT_DIR$/ultrasonic" />
-          </set>
-        </option>
-        <option name="resolveModulePerSourceSet" value="false" />
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,8 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Reformat" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="processChangedFilesOnly" value="true" />
+    </inspection_tool>
+  </profile>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK" />
+</project>

.idea/modules.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/library/library.iml" filepath="$PROJECT_DIR$/library/library.iml" />
-      <module fileurl="file://$PROJECT_DIR$/menudrawer/menudrawer.iml" filepath="$PROJECT_DIR$/menudrawer/menudrawer.iml" />
-      <module fileurl="file://$PROJECT_DIR$/pulltorefresh/pulltorefresh.iml" filepath="$PROJECT_DIR$/pulltorefresh/pulltorefresh.iml" />
-      <module fileurl="file://$PROJECT_DIR$/ultrasonic.iml" filepath="$PROJECT_DIR$/ultrasonic.iml" />
-      <module fileurl="file://$PROJECT_DIR$/ultrasonic/ultrasonic-ultrasonic.iml" filepath="$PROJECT_DIR$/ultrasonic/ultrasonic-ultrasonic.iml" />
-    </modules>
-  </component>
-</project>

.idea/runConfigurations.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunConfigurationProducerService">
-    <option name="ignoredProducers">
-      <set>
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
-      </set>
-    </option>
-  </component>
-</project>

.tx/config

@@ -0,0 +1,10 @@
+[main]
+host = https://www.transifex.com
+lang_map = nl_NL:nl,pl_PL:pl,fr_CA:fr-rCA,pt_BR:pt-rBR,pt_PT:pt,zh_CN:zh-rCN,zh_HK:zh-rHK,zh_TW:zh-rTW,da_DK:da-rDK,de_DE:de,tr_TR:tr,fr_FR:fr,es_ES:es,hu_HU:hu,sv_SE:sv-rSE,bg_BG:bg,el_GR:el,kn_IN:kn-rIN,cs_CZ:cs,sr:sr,he:iw,id:in,lt_LT:lt,km_KH:km-rKH,th_TH:th,ru_RU:ru,it_IT:it
+
+[ultrasonic.app]
+file_filter = ultrasonic/src/main/res/values-<lang>/strings.xml
+source_file = ultrasonic/src/main/res/values/strings.xml
+source_lang = en
+type = ANDROID
+

CONTRIBUTING.md

@@ -0,0 +1,63 @@
+# Contributing
+
+Ultrasonic development is a community project, and contributions are welcomed.
+
+First, see if your issue haven’t been yet reported [here](https://github.com/ultrasonic/ultrasonic/issues),
+then, please, first discuss the change you wish to make via [a new issue](https://github.com/ultrasonic/ultrasonic/issues/new).
+
+## Contributing Translations
+
+Interested in help to translate Ultrasonic? You can contribute in our
+[Transifex team](https://www.transifex.com/ultrasonic/ultrasonic/).
+
+## Contributing Code
+
+By default Pull Request should be opened against **develop** branch, PR against **master** branch should be used only
+ for critical bugfixes.
+
+### Here are a few guidelines you should follow before submitting:
+
+1. **License Acceptance:** All contributions must be licensed as [GNU GPLv3](LICENSE) to be accepted.
+Use `git commit --signoff` to acknowledge this. 
+2. **No Breakage:** New features or changes to existing ones must not degrade the user experience.
+3. **Coding standards:** best-practices should be followed, comment generously, and avoid "clever" algorithms.
+Refactoring existing messes is great, but watch out for breakage.
+4. **No large PR:** Try to limit the scope of PR only to the related issue, so it will be easier to review
+and test.
+
+### Pull Request Process
+On each Pull Request Github runs a number of checks to make sure there are no problems.
+
+#### Signed commits
+Commits must be signed. [See here how to set it up](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits)
+
+#### KtLint
+This programm checks if the source code is formatted correctly.
+You can run it yourself locally with 
+
+`./gradlew -Pqc ktlintFormat`
+
+Running this command will fix common problems and will notify you of problems it couldn't fix automatically.
+
+#### Detekt
+
+Detekt is a static analyser. It helps to find potential bugs in our code.
+
+You can run it yourself locally with 
+
+`./gradlew -Pqc detekt`
+
+There is a "baseline" file, in which errors which have been in the code base before are noted.
+Sometimes it is necessary to regenerate this file by running:
+
+`./gradlew -Pqc detektBaseline`
+
+#### Lint
+Lint looks for general problems in the code or unused resources etc. 
+You can run it with
+
+`./gradlew -Pqc lintRelease`
+
+If there is a need to regenerate the baseline, remove `ultrasonic/lint-baseline.xml` and rerun the command.
+
+

ISSUE_TEMPLATE.md

@@ -1 +1,28 @@
-Please, take note that this project is STALLED. See README.md for more info.
+## Problem description
+
+Describe your problem here. Describe what you want to happen, and what
+happens if you try to do it. If you have a stack trace or any logs, please
+format them using GitHub triple backquote notation.
+
+### Steps to reproduce
+
+Describe how somebody else could observe the same behavior you do. Don't
+share here any logins and passwords!
+
+## System information
+
+### Ultrasonic client
+
+ * **Ultrasonic version**: *version of the app*
+ * **Android version**: *Version of Android OS on the device*
+ * **Device info**: *Device manufacturer, model*
+
+### Server
+
+ * **Server name**: *Airsonic, Ampache, Supysonic...*
+ * **Server version**: *version of server software*
+ * **Protocol used**: *http or https (self certificate, letsencrypt...)*
+
+## Additional notes
+
+Include any extra notes here. Otherwise you may remove this section.

README.md

@@ -1,12 +1,82 @@
+# WE HAVE MOVED
+
+Ultrasonic code is now hosted in [GitLab][ultrasonic].
+
+- New Web: https://ultrasonic.gitlab.io
+- New Git: https://gitlab.com/ultrasonic/ultrasonic
+- New bugtracker: https://gitlab.com/ultrasonic/ultrasonic/-/issues
+- New releases: https://gitlab.com/ultrasonic/ultrasonic/-/packages
+
+[ultrasonic]: https://gitlab.com/ultrasonic/ultrasonic
+
 # Ultrasonic
-Subsonic Music Streamer Android client
 
-## About project status
+Ultrasonic is free and open-source music streaming Android client for
+[Subsonic][subsonic] [API][subapi] (version 1.7.0 or higher) compatible
+servers.
 
-WARNING: This project is **STALLED**
+## Help wanted
 
-This means that I don't have time to fix bugs or add new features, but you can send me **Pull Requests** and I **promise** that I shall merge and upload to Play Store.
+We currently don't have that much time to spend developing Subsonic, so any
+contributions or active developers are always welcomed.
+Have a look at [CONTRIBUTING](CONTRIBUTING.md) to get started.
 
-If you want contribute at project you can see the [issues](https://github.com/ogarcia/ultrasonic/issues) page and try to fix the discovered bugs or implement the enhancements that users report there.
+## Download
 
-If you want give more active development, please contact with me cause I can give you access to repository to do work faster.
+App is available to download at following stores:
+
+[<img src="https://play.google.com/intl/en_us/badges/images/generic/en-play-badge.png" alt="Get it on Google Play" height="70">](https://play.google.com/store/apps/details?id=org.moire.ultrasonic)
+[<img src="https://f-droid.org/badge/get-it-on.png" alt="Get it on F-Droid" height="70">](https://f-droid.org/packages/org.moire.ultrasonic/)
+[<img src="https://ultrasonic.gitlab.io/assets/img/get-it-on-gitlab.png" alt="Get it on GitLab" height="70">](https://gitlab.com/ultrasonic/ultrasonic/-/releases)
+
+**Warning**: All three versions (Google Play, F-Droid and the APKs) are not
+compatible (not signed by the same key)! You must uninstall one to install
+the other, which will delete all your data.
+
+If you want to use the version downloaded from F-Droid or from GitLab with
+**Android Auto**, you must enable Unknown Sources as it is described in
+[this wiki page][wikiaa].
+
+## Bugs and issues
+
+First, see if your issue haven’t been yet reported [here][issues], otherwise
+open [a new issue][newissue].
+
+### Known (not our) bugs
+
+If you are using *Madsonic 5.1.X* several sections of Ultrasonic will not
+work. This is caused by bad implementation of Subsonic API by Madsonic. For
+more info about this you can read [this bug][madbug].
+
+## Contributing
+
+See [CONTRIBUTING](CONTRIBUTING.md).
+
+## Supported (tested) Subsonic API implementations
+
+- [Subsonic][subsonic]
+- [Airsonic-Advanced][airsonic]
+- [Supysonic][supysonic]
+- [Ampache][ampache]
+
+Other *Subsonic API* implementations should work as well as long as they
+follow API [documentation][subapi].
+
+## License
+
+This software is licensed under the terms of the GNU General Public License
+version 3 (GPLv3).
+
+Full text of the license is available in the [LICENSE](LICENSE) file and
+[online][gpl3].
+
+[wikiaa]: https://gitlab.com/ultrasonic/ultrasonic/-/wikis/Using-Ultrasonic-with-Android-Auto
+[issues]: https://gitlab.com/ultrasonic/ultrasonic/-/issues
+[newissue]: https://gitlab.com/ultrasonic/ultrasonic/-/issues/new
+[madbug]: https://gitlab.com/ultrasonic/ultrasonic/-/issues/129
+[subsonic]: http://www.subsonic.org/
+[subapi]: http://www.subsonic.org/pages/api.jsp
+[airsonic]: https://github.com/airsonic-advanced/airsonic-advanced
+[supysonic]: https://github.com/spl0k/supysonic
+[ampache]: https://ampache.org/
+[gpl3]: https://opensource.org/licenses/gpl-3.0.html

build.gradle

@@ -1,19 +1,49 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
-apply from: 'dependencies.gradle'
-
 buildscript {
-    apply from: 'dependencies.gradle'
+    apply from: 'gradle/versions.gradle'
+
+    ext.bootstrap = [
+            kotlinModule : "${project.rootDir}/gradle_scripts/kotlin-module-bootstrap.gradle",
+            androidModule : "${project.rootDir}/gradle_scripts/android-module-bootstrap.gradle"
+    ]
 
     repositories {
-        jcenter()
+        google()
+        mavenCentral()
+        maven { url "https://plugins.gradle.org/m2/" }
     }
     dependencies {
-        classpath gradlePlugins.androidTools
+        classpath libs.gradle
+        classpath libs.kotlin
+        classpath libs.ktlintGradle
+        classpath libs.detekt
     }
 }
 
 allprojects {
+    // Buildscript here is required by detekt
+    buildscript {
+        repositories {
+            mavenCentral()
+            google()
+        }
+    }
+
     repositories {
-        jcenter()
+        mavenCentral()
+        google()
+        maven { url 'https://jitpack.io' }
+    }
+
+    // Set Kotlin JVM target to the same for all subprojects
+    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+        kotlinOptions {
+            jvmTarget = "1.8"
+        }
     }
 }
+
+wrapper {
+    gradleVersion(libs.versions.gradle.get())
+    distributionType("all")
+}

core/domain/build.gradle

@@ -0,0 +1,8 @@
+apply from: bootstrap.androidModule
+apply plugin: 'kotlin-kapt'
+
+dependencies {
+    implementation libs.roomRuntime
+    implementation libs.roomKtx
+    kapt libs.room
+}

core/domain/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.moire.ultrasonic.subsonic.domain">
+</manifest>

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Album.kt

@@ -0,0 +1,38 @@
+/*
+ * Album.kt
+ * Copyright (C) 2009-2022 Ultrasonic developers
+ *
+ * Distributed under terms of the GNU GPLv3 license.
+ */
+
+package org.moire.ultrasonic.domain
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import java.util.Date
+
+@Entity(tableName = "albums", primaryKeys = ["id", "serverId"])
+data class Album(
+    override var id: String,
+    @ColumnInfo(defaultValue = "-1")
+    override var serverId: Int = -1,
+    override var parent: String? = null,
+    override var album: String? = null,
+    override var title: String? = null,
+    override val name: String? = null,
+    override var discNumber: Int? = 0,
+    override var coverArt: String? = null,
+    override var songCount: Long? = null,
+    override var created: Date? = null,
+    override var artist: String? = null,
+    override var artistId: String? = null,
+    override var duration: Int? = 0,
+    override var year: Int? = 0,
+    override var genre: String? = null,
+    override var starred: Boolean = false,
+    override var path: String? = null,
+    override var closeness: Int = 0,
+) : MusicDirectory.Child() {
+    override var isDirectory = true
+    override var isVideo = false
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Artist.kt

@@ -0,0 +1,23 @@
+/*
+ * Artist.kt
+ * Copyright (C) 2009-2022 Ultrasonic developers
+ *
+ * Distributed under terms of the GNU GPLv3 license.
+ */
+
+package org.moire.ultrasonic.domain
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+
+@Entity(tableName = "artists", primaryKeys = ["id", "serverId"])
+data class Artist(
+    override var id: String,
+    @ColumnInfo(defaultValue = "-1")
+    override var serverId: Int = -1,
+    override var name: String? = null,
+    override var index: String? = null,
+    override var coverArt: String? = null,
+    override var albumCount: Long? = null,
+    override var closeness: Int = 0
+) : ArtistOrIndex(id, serverId)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/ArtistOrIndex.kt

@@ -0,0 +1,45 @@
+/*
+ * ArtistOrIndex.kt
+ * Copyright (C) 2009-2022 Ultrasonic developers
+ *
+ * Distributed under terms of the GNU GPLv3 license.
+ */
+
+package org.moire.ultrasonic.domain
+
+import androidx.room.Ignore
+
+@Suppress("LongParameterList")
+abstract class ArtistOrIndex(
+    @Ignore
+    override var id: String,
+    @Ignore
+    open var serverId: Int,
+    @Ignore
+    override var name: String? = null,
+    @Ignore
+    open var index: String? = null,
+    @Ignore
+    open var coverArt: String? = null,
+    @Ignore
+    open var albumCount: Long? = null,
+    @Ignore
+    open var closeness: Int = 0
+) : GenericEntry() {
+
+    fun compareTo(other: ArtistOrIndex): Int {
+        return when {
+            this.closeness == other.closeness -> {
+                0
+            }
+            this.closeness > other.closeness -> {
+                -1
+            }
+            else -> {
+                1
+            }
+        }
+    }
+
+    override fun compareTo(other: Identifiable) = compareTo(other as ArtistOrIndex)
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Bookmark.kt

@@ -0,0 +1,17 @@
+package org.moire.ultrasonic.domain
+
+import java.io.Serializable
+import java.util.Date
+
+data class Bookmark(
+    val position: Int = 0,
+    val username: String,
+    val comment: String,
+    val created: Date? = null,
+    val changed: Date? = null,
+    val track: Track
+) : Serializable {
+    companion object {
+        private const val serialVersionUID = 8988990025189807803L
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/ChatMessage.kt

@@ -0,0 +1,13 @@
+package org.moire.ultrasonic.domain
+
+import java.io.Serializable
+
+data class ChatMessage(
+    val username: String,
+    val time: Long,
+    val message: String
+) : Serializable {
+    companion object {
+        private const val serialVersionUID = 496544310289324167L
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Genre.kt

@@ -0,0 +1,15 @@
+package org.moire.ultrasonic.domain
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import java.io.Serializable
+
+@Entity
+data class Genre(
+    @PrimaryKey val index: String,
+    val name: String
+) : Serializable {
+    companion object {
+        private const val serialVersionUID = -3943025175219134028L
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Identifiable.kt

@@ -0,0 +1,19 @@
+package org.moire.ultrasonic.domain
+
+import androidx.room.Ignore
+
+abstract class GenericEntry : Identifiable {
+    @Ignore
+    open val name: String? = null
+}
+
+interface Identifiable : Comparable<Identifiable> {
+    val id: String
+
+    val longId: Long
+        get() = id.hashCode().toLong()
+
+    override fun compareTo(other: Identifiable): Int {
+        return longId.compareTo(other.longId)
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Index.kt

@@ -0,0 +1,24 @@
+/*
+ * Index.kt
+ * Copyright (C) 2009-2022 Ultrasonic developers
+ *
+ * Distributed under terms of the GNU GPLv3 license.
+ */
+
+package org.moire.ultrasonic.domain
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+
+@Entity(tableName = "indexes", primaryKeys = ["id", "serverId"])
+data class Index(
+    override var id: String,
+    @ColumnInfo(defaultValue = "-1")
+    override var serverId: Int = -1,
+    override var name: String? = null,
+    override var index: String? = null,
+    override var coverArt: String? = null,
+    override var albumCount: Long? = null,
+    override var closeness: Int = 0,
+    var musicFolderId: String? = null
+) : ArtistOrIndex(id, serverId)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/JukeboxStatus.kt

@@ -0,0 +1,8 @@
+package org.moire.ultrasonic.domain
+
+data class JukeboxStatus(
+    var positionSeconds: Int? = null,
+    var currentPlayingIndex: Int? = null,
+    var gain: Float? = null,
+    var isPlaying: Boolean = false
+)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Lyrics.kt

@@ -0,0 +1,10 @@
+package org.moire.ultrasonic.domain
+
+/**
+ * Song lyrics.
+ */
+data class Lyrics(
+    val artist: String? = null,
+    val title: String? = null,
+    val text: String? = null
+)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/MusicDirectory.kt

@@ -0,0 +1,61 @@
+/*
+ * MusicDirectory.kt
+ * Copyright (C) 2009-2022 Ultrasonic developers
+ *
+ * Distributed under terms of the GNU GPLv3 license.
+ */
+
+package org.moire.ultrasonic.domain
+
+import java.util.Date
+
+class MusicDirectory : ArrayList<MusicDirectory.Child>() {
+    var name: String? = null
+
+    @JvmOverloads
+    fun getChildren(
+        includeDirs: Boolean = true,
+        includeFiles: Boolean = true
+    ): List<Child> {
+        if (includeDirs && includeFiles) {
+            return toList()
+        }
+
+        return filter { it.isDirectory && includeDirs || !it.isDirectory && includeFiles }
+    }
+
+    fun getTracks(): List<Track> {
+        return mapNotNull {
+            it as? Track
+        }
+    }
+
+    fun getAlbums(): List<Album> {
+        return mapNotNull {
+            it as? Album
+        }
+    }
+
+    abstract class Child : GenericEntry() {
+        abstract override var id: String
+        abstract var serverId: Int
+        abstract var parent: String?
+        abstract var isDirectory: Boolean
+        abstract var album: String?
+        abstract var title: String?
+        abstract override val name: String?
+        abstract var discNumber: Int?
+        abstract var coverArt: String?
+        abstract var songCount: Long?
+        abstract var created: Date?
+        abstract var artist: String?
+        abstract var artistId: String?
+        abstract var duration: Int?
+        abstract var year: Int?
+        abstract var genre: String?
+        abstract var starred: Boolean
+        abstract var path: String?
+        abstract var closeness: Int
+        abstract var isVideo: Boolean
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/MusicFolder.kt

@@ -0,0 +1,22 @@
+/*
+ * MusicFolder.kt
+ * Copyright (C) 2009-2022 Ultrasonic developers
+ *
+ * Distributed under terms of the GNU GPLv3 license.
+ */
+
+package org.moire.ultrasonic.domain
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+
+/**
+ * Represents a top level directory in which music or other media is stored.
+ */
+@Entity(tableName = "music_folders", primaryKeys = ["id", "serverId"])
+data class MusicFolder(
+    override val id: String,
+    override val name: String,
+    @ColumnInfo(defaultValue = "-1")
+    var serverId: Int
+) : GenericEntry()

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Playlist.kt

@@ -0,0 +1,17 @@
+package org.moire.ultrasonic.domain
+
+import java.io.Serializable
+
+data class Playlist @JvmOverloads constructor(
+    override val id: String,
+    override var name: String,
+    val owner: String = "",
+    val comment: String = "",
+    val songCount: String = "",
+    val created: String = "",
+    val public: Boolean? = null
+) : Serializable, GenericEntry() {
+    companion object {
+        private const val serialVersionUID = -4160515427075433798L
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/PodcastsChannel.kt

@@ -0,0 +1,15 @@
+package org.moire.ultrasonic.domain
+
+import java.io.Serializable
+
+data class PodcastsChannel(
+    override val id: String,
+    val title: String?,
+    val url: String?,
+    val description: String?,
+    val status: String?
+) : Serializable, GenericEntry() {
+    companion object {
+        private const val serialVersionUID = -4160515427075433798L
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/SearchCriteria.kt

@@ -0,0 +1,11 @@
+package org.moire.ultrasonic.domain
+
+/**
+ * The criteria for a music search.
+ */
+data class SearchCriteria(
+    val query: String,
+    val artistCount: Int,
+    val albumCount: Int,
+    val songCount: Int
+)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/SearchResult.kt

@@ -0,0 +1,10 @@
+package org.moire.ultrasonic.domain
+
+/**
+ * The result of a search.  Contains matching artists, albums and songs.
+ */
+data class SearchResult(
+    val artists: List<ArtistOrIndex> = listOf(),
+    val albums: List<Album> = listOf(),
+    val songs: List<Track> = listOf()
+)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Share.kt

@@ -0,0 +1,36 @@
+package org.moire.ultrasonic.domain
+
+import java.io.Serializable
+
+data class Share(
+    override var id: String,
+    var url: String? = null,
+    var description: String? = null,
+    var username: String? = null,
+    var created: String? = null,
+    var lastVisited: String? = null,
+    var expires: String? = null,
+    var visitCount: Long? = null,
+    private val tracks: MutableList<Track> = mutableListOf()
+) : Serializable, GenericEntry() {
+    override val name: String?
+        get() {
+            if (url != null) {
+                return urlPattern.matcher(url!!).replaceFirst("$1")
+            }
+            return null
+        }
+
+    fun getEntries(): List<Track> {
+        return tracks.toList()
+    }
+
+    fun addEntry(track: Track) {
+        tracks.add(track)
+    }
+
+    companion object {
+        private const val serialVersionUID = 1487561657691009668L
+        private val urlPattern = ".*/([^/?]+).*".toPattern()
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Track.kt

@@ -0,0 +1,74 @@
+/*
+ * Track.kt
+ * Copyright (C) 2009-2022 Ultrasonic developers
+ *
+ * Distributed under terms of the GNU GPLv3 license.
+ */
+
+package org.moire.ultrasonic.domain
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import java.io.Serializable
+import java.util.Date
+
+@Entity(tableName = "tracks", primaryKeys = ["id", "serverId"])
+data class Track(
+    override var id: String,
+    @ColumnInfo(defaultValue = "-1")
+    override var serverId: Int = -1,
+    override var parent: String? = null,
+    override var isDirectory: Boolean = false,
+    override var title: String? = null,
+    override var album: String? = null,
+    var albumId: String? = null,
+    override var artist: String? = null,
+    override var artistId: String? = null,
+    var track: Int? = null,
+    override var year: Int? = null,
+    override var genre: String? = null,
+    var contentType: String? = null,
+    var suffix: String? = null,
+    var transcodedContentType: String? = null,
+    var transcodedSuffix: String? = null,
+    override var coverArt: String? = null,
+    var size: Long? = null,
+    override var songCount: Long? = null,
+    override var duration: Int? = null,
+    var bitRate: Int? = null,
+    override var path: String? = null,
+    override var isVideo: Boolean = false,
+    override var starred: Boolean = false,
+    override var discNumber: Int? = null,
+    var type: String? = null,
+    override var created: Date? = null,
+    override var closeness: Int = 0,
+    var bookmarkPosition: Int = 0,
+    var userRating: Int? = null,
+    var averageRating: Float? = null,
+    override var name: String? = null
+) : Serializable, MusicDirectory.Child() {
+    fun setDuration(duration: Long) {
+        this.duration = duration.toInt()
+    }
+
+    companion object {
+        private const val serialVersionUID = -3339106650010798108L
+    }
+
+    fun compareTo(other: Track): Int {
+        when {
+            this.closeness == other.closeness -> {
+                return 0
+            }
+            this.closeness > other.closeness -> {
+                return -1
+            }
+            else -> {
+                return 1
+            }
+        }
+    }
+
+    override fun compareTo(other: Identifiable) = compareTo(other as Track)
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/UserInfo.kt

@@ -0,0 +1,21 @@
+package org.moire.ultrasonic.domain
+
+/**
+ * Information about user
+ */
+data class UserInfo(
+    val userName: String? = null,
+    val email: String? = null,
+    val scrobblingEnabled: Boolean = false,
+    val adminRole: Boolean = false,
+    val settingsRole: Boolean = false,
+    val downloadRole: Boolean = false,
+    val uploadRole: Boolean = false,
+    val playlistRole: Boolean = false,
+    val coverArtRole: Boolean = false,
+    val commentRole: Boolean = false,
+    val podcastRole: Boolean = false,
+    val streamRole: Boolean = false,
+    val jukeboxRole: Boolean = false,
+    val shareRole: Boolean = false
+)

core/subsonic-api/build.gradle

@@ -0,0 +1,22 @@
+apply from: bootstrap.kotlinModule
+
+dependencies {
+    api libs.retrofit
+    api libs.jacksonConverter
+    api libs.koinCore
+
+    implementation(libs.jacksonKotlin) {
+        exclude module: 'kotlin-reflect'
+    }
+    implementation libs.kotlinReflect // for jackson kotlin, but to use the same version
+    implementation libs.okhttpLogging
+    implementation libs.timber
+
+    testImplementation libs.kotlinJunit
+    testImplementation libs.mockito
+    testImplementation libs.mockitoInline
+    testImplementation libs.mockitoKotlin
+    testImplementation libs.kluent
+    testImplementation libs.mockWebServer
+    testImplementation libs.apacheCodecs
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/CommonFunctions.kt

@@ -0,0 +1,98 @@
+package org.moire.ultrasonic.api.subsonic
+
+import java.io.InputStream
+import java.nio.charset.Charset
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Locale
+import java.util.TimeZone
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okio.buffer
+import okio.source
+import org.amshove.kluent.`should be`
+import org.amshove.kluent.`should contain`
+import org.amshove.kluent.`should not be`
+import org.moire.ultrasonic.api.subsonic.response.SubsonicResponse
+import org.moire.ultrasonic.api.subsonic.rules.MockWebServerRule
+import retrofit2.Response
+
+const val USERNAME = "some-user"
+const val PASSWORD = "some-password"
+val CLIENT_VERSION = SubsonicAPIVersions.V1_16_0
+const val CLIENT_ID = "test-client"
+
+val dateFormat by lazy(
+    LazyThreadSafetyMode.NONE
+) {
+    SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.US)
+}
+
+fun MockWebServerRule.enqueueResponse(resourceName: String) {
+    mockWebServer.enqueueResponse(resourceName)
+}
+
+fun MockWebServer.enqueueResponse(resourceName: String) {
+    enqueue(
+        MockResponse()
+            .setBody(loadJsonResponse(resourceName))
+            .setHeader("Content-Type", "application/json;charset=UTF-8")
+    )
+}
+
+fun Any.loadJsonResponse(name: String): String {
+    val source = javaClass.classLoader.getResourceAsStream(name)!!.source().buffer()
+    return source.readString(Charset.forName("UTF-8"))
+}
+
+fun Any.loadResourceStream(name: String): InputStream {
+    val source = javaClass.classLoader.getResourceAsStream(name)!!.source().buffer()
+    return source.inputStream()
+}
+
+fun <T> assertResponseSuccessful(response: Response<T>) {
+    response.isSuccessful `should be` true
+    response.body() `should not be` null
+}
+
+fun parseDate(dateAsString: String): Calendar {
+    val result = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+    result.time = dateFormat.parse(dateAsString.replace("Z$".toRegex(), "+0000"))
+
+    return result
+}
+
+fun <T : SubsonicResponse> checkErrorCallParsed(
+    mockWebServerRule: MockWebServerRule,
+    apiRequest: () -> Response<T>
+): T {
+    mockWebServerRule.enqueueResponse("request_data_not_found_error_response.json")
+
+    val response = apiRequest()
+
+    assertResponseSuccessful(response)
+    with(response.body()!!) {
+        status `should be` SubsonicResponse.Status.ERROR
+        error `should be` SubsonicError.RequestedDataWasNotFound
+    }
+    return response.body()!!
+}
+
+fun SubsonicResponse.assertBaseResponseOk() {
+    status `should be` SubsonicResponse.Status.OK
+    version `should be` SubsonicAPIVersions.V1_13_0
+    error `should be` null
+}
+
+fun MockWebServerRule.assertRequestParam(
+    responseResourceName: String = "ping_ok.json",
+    expectedParam: String,
+    apiRequest: () -> Response<out Any>
+) {
+    this.enqueueResponse(responseResourceName)
+    apiRequest()
+
+    val request = this.mockWebServer.takeRequest()
+
+    request.requestLine `should contain` expectedParam
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicAPIClientTest.kt

@@ -0,0 +1,27 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Before
+import org.junit.Rule
+import org.moire.ultrasonic.api.subsonic.rules.MockWebServerRule
+
+/**
+ * Base class for integration tests for [SubsonicAPIClient] class.
+ */
+abstract class SubsonicAPIClientTest {
+    @JvmField @Rule val mockWebServerRule = MockWebServerRule()
+
+    protected lateinit var config: SubsonicClientConfiguration
+    protected lateinit var client: SubsonicAPIClient
+
+    @Before
+    open fun setUp() {
+        config = SubsonicClientConfiguration(
+            mockWebServerRule.mockWebServer.url("/").toString(),
+            USERNAME,
+            PASSWORD,
+            CLIENT_VERSION,
+            CLIENT_ID
+        )
+        client = SubsonicAPIClient(config)
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiAddChatMessageTest.kt

@@ -0,0 +1,33 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIDefinition.addChatMessage] call.
+ */
+class SubsonicApiAddChatMessageTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.addChatMessage("some").execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.addChatMessage("some").execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass message in request param`() {
+        val message = "Youuhuuu"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "message=$message") {
+            client.api.addChatMessage(message = message).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiCreateBookmarkTest.kt

@@ -0,0 +1,51 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIDefinition.createBookmark] call.
+ */
+class SubsonicApiCreateBookmarkTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.createBookmark("1", 1).execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.createBookmark("213", 123213L).execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass id in request params`() {
+        val id = "544"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "id=$id") {
+            client.api.createBookmark(id = id, position = 123).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass position in request params`() {
+        val position = 4412333L
+
+        mockWebServerRule.assertRequestParam(expectedParam = "position=$position") {
+            client.api.createBookmark(id = "12", position = position).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass comment in request params`() {
+        val comment = "some-comment"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "comment=$comment") {
+            client.api.createBookmark(id = "1", position = 1, comment = comment).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiCreatePlaylistTest.kt

@@ -0,0 +1,60 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] for createPlaylist call.
+ */
+class SubsonicApiCreatePlaylistTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.createPlaylist().execute()
+        }
+    }
+
+    @Test
+    fun `Should hanlde ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.createPlaylist().execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass id param in request`() {
+        val id = "56"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "playlistId=$id"
+        ) {
+            client.api.createPlaylist(id = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass name param in request`() {
+        val name = "some-name"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "name=$name"
+        ) {
+            client.api.createPlaylist(name = name).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass song id param in request`() {
+        val songId = listOf("4410", "852")
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "songId=${songId[0]}&songId=${songId[1]}"
+        ) {
+            client.api.createPlaylist(songIds = songId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiCreateShareTest.kt

@@ -0,0 +1,83 @@
+package org.moire.ultrasonic.api.subsonic
+
+import java.util.Calendar
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Instrumentation test for [SubsonicAPIDefinition.createShare] call.
+ */
+class SubsonicApiCreateShareTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error responce`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.createShare(listOf("some-id")).execute()
+        }
+
+        response.shares `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_shares_ok.json")
+
+        val response = client.api.createShare(listOf("some-id")).execute()
+
+        assertResponseSuccessful(response)
+        response.body()!!.shares.size `should be equal to` 1
+        with(response.body()!!.shares[0]) {
+            id `should be equal to` "0"
+            url `should be equal to` "https://subsonic.com/ext/share/awdwo?jwt=" +
+                "eyJhbGciOiJIUzI1NiJ9." +
+                "eyJwYXRoIjoiL2V4dC9zaGFyZS9hd2R3byIsImV4cCI6MTU0MTYyNjQzMX0.iy8dkt_ZZc8hJ692" +
+                "UxorHdHWFU2RB-fMCmCA4IJ_dTw"
+            username `should be equal to` "admin"
+            created `should be equal to` parseDate("2017-11-07T21:33:51.748Z")
+            expires `should be equal to` parseDate("2018-11-07T21:33:51.748Z")
+            lastVisited `should be equal to` parseDate("2018-11-07T21:33:51.748Z")
+            description `should be equal to` "Awesome link!"
+            visitCount `should be equal to` 0
+            items.size `should be equal to` 1
+            items[0] `should be equal to` MusicDirectoryChild(
+                id = "4212", parent = "4186", isDir = false,
+                title = "Heaven Knows", album = "Going to Hell", artist = "The Pretty Reckless",
+                track = 3, year = 2014, genre = "Hard Rock", coverArt = "4186", size = 9025090,
+                contentType = "audio/mpeg", suffix = "mp3", duration = 225, bitRate = 320,
+                path = "The Pretty Reckless/Going to Hell/03 Heaven Knows.mp3", isVideo = false,
+                playCount = 2, discNumber = 1,
+                created = parseDate("2016-10-23T21:30:40.000Z"),
+                albumId = "388", artistId = "238", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass ids in request param`() {
+        val idsList = listOf("some-id1", "some-id2")
+        mockWebServerRule.assertRequestParam(
+            expectedParam = "id=${idsList[0]}&id=${idsList[1]}"
+        ) {
+            client.api.createShare(idsList).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass description in request param`() {
+        val description = "description-banana"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "description=$description") {
+            client.api.createShare(idsToShare = listOf("id1", "id2"), description = description)
+                .execute()
+        }
+    }
+
+    @Test
+    fun `Should pass expires in request param`() {
+        val expires = Calendar.getInstance().timeInMillis
+
+        mockWebServerRule.assertRequestParam(expectedParam = "expires=$expires") {
+            client.api.createShare(idsToShare = listOf("id1"), expires = expires).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiDeleteBookmarkTest.kt

@@ -0,0 +1,33 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIDefinition.deleteBookmark] call.
+ */
+class SubsonicApiDeleteBookmarkTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.deleteBookmark("1").execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.deleteBookmark("1").execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass id in request params`() {
+        val id = "233"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "id=$id") {
+            client.api.deleteBookmark(id).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiDeletePlaylistTest.kt

@@ -0,0 +1,36 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Instrumentation test for [SubsonicAPIClient] for deletePlaylist call.
+ */
+class SubsonicApiDeletePlaylistTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.deletePlaylist("10").execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.deletePlaylist("10").execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass id param in request`() {
+        val id = "534"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.deletePlaylist(id).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiDeleteShareTest.kt

@@ -0,0 +1,33 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIDefinition.deleteShare] call.
+ */
+class SubsonicApiDeleteShareTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.deleteShare("123").execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.deleteShare("12").execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass id in request params`() {
+        val id = "224"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "id=$id") {
+            client.api.deleteShare(id).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiErrorsTest.kt

@@ -0,0 +1,157 @@
+package org.moire.ultrasonic.api.subsonic
+
+import java.io.IOException
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.amshove.kluent.`should throw`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.SubsonicError.Generic
+import org.moire.ultrasonic.api.subsonic.SubsonicError.IncompatibleClientProtocolVersion
+import org.moire.ultrasonic.api.subsonic.SubsonicError.IncompatibleServerProtocolVersion
+import org.moire.ultrasonic.api.subsonic.SubsonicError.RequestedDataWasNotFound
+import org.moire.ultrasonic.api.subsonic.SubsonicError.RequiredParamMissing
+import org.moire.ultrasonic.api.subsonic.SubsonicError.TokenAuthNotSupportedForLDAP
+import org.moire.ultrasonic.api.subsonic.SubsonicError.TrialPeriodIsOver
+import org.moire.ultrasonic.api.subsonic.SubsonicError.UserNotAuthorizedForOperation
+import org.moire.ultrasonic.api.subsonic.SubsonicError.WrongUsernameOrPassword
+import org.moire.ultrasonic.api.subsonic.response.SubsonicResponse
+import retrofit2.Response
+
+/**
+ * Integration test that checks validity of api errors parsing.
+ */
+class SubsonicApiErrorsTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse wrong username or password error`() {
+        mockWebServerRule.enqueueResponse("wrong_username_or_password_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(WrongUsernameOrPassword)
+    }
+
+    @Test
+    fun `Should parse generic error with message`() {
+        mockWebServerRule.enqueueResponse("generic_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(Generic("Some generic error message."))
+    }
+
+    @Test
+    fun `Should fail on unknown error`() {
+        mockWebServerRule.enqueueResponse("unexpected_error.json")
+
+        val fail = {
+            client.api.ping().execute()
+        }
+
+        fail `should throw` IOException::class
+    }
+
+    @Test
+    fun `Should parse required param missing error`() {
+        mockWebServerRule.enqueueResponse("required_param_missing_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(RequiredParamMissing)
+    }
+
+    @Test
+    fun `Should parse incompatible client protocol version error`() {
+        mockWebServerRule.enqueueResponse("incompatible_client_protocol_version_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(IncompatibleClientProtocolVersion)
+    }
+
+    @Test
+    fun `Should parse incompatible server protocol version error`() {
+        mockWebServerRule.enqueueResponse("incompatible_server_protocol_version_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(IncompatibleServerProtocolVersion)
+    }
+
+    @Test
+    fun `Should parse token auth not supported for ldap error`() {
+        mockWebServerRule.enqueueResponse("token_auth_not_supported_for_ldap_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(TokenAuthNotSupportedForLDAP)
+    }
+
+    @Test
+    fun `Should parse user not authorized for operation error`() {
+        mockWebServerRule.enqueueResponse("user_not_authorized_for_operation_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(UserNotAuthorizedForOperation)
+    }
+
+    @Test
+    fun `Should parse trial period is over error`() {
+        mockWebServerRule.enqueueResponse("trial_period_is_over_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(TrialPeriodIsOver)
+    }
+
+    @Test
+    fun `Should parse requested data was not found error`() {
+        mockWebServerRule.enqueueResponse("requested_data_was_not_found_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(RequestedDataWasNotFound)
+    }
+
+    @Test
+    fun `Should parse error with reversed tokens order`() {
+        mockWebServerRule.enqueueResponse("reversed_tokens_generic_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(Generic("Video streaming not supported"))
+    }
+
+    @Test
+    fun `Should parse error if json contains error first before other fields`() {
+        mockWebServerRule.enqueueResponse("error_first_generic_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(Generic("Video streaming not supported"))
+    }
+
+    @Test
+    fun `Should parse error if json doesn't contain message field`() {
+        mockWebServerRule.enqueueResponse("without_message_generic_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(Generic(""))
+    }
+
+    @Test
+    fun `Should parse error if error json contains additional object`() {
+        mockWebServerRule.enqueueResponse("with_additional_json_object_generic_error.json")
+
+        val response = client.api.ping().execute()
+
+        response.assertError(Generic(""))
+    }
+
+    private fun Response<SubsonicResponse>.assertError(expectedError: SubsonicError) =
+        with(body()!!) {
+            error `should not be` null
+            error `should be equal to` expectedError
+        }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetAlbumList2Test.kt

@@ -0,0 +1,130 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Album
+import org.moire.ultrasonic.api.subsonic.models.AlbumListType
+import org.moire.ultrasonic.api.subsonic.models.AlbumListType.STARRED
+
+/**
+ * Integration test for [SubsonicAPIClient] for getAlbumList2() call.
+ */
+@Suppress("NamingConventionViolation")
+class SubsonicApiGetAlbumList2Test : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getAlbumList2(STARRED).execute()
+        }
+
+        response.albumList `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_album_list_2_ok.json")
+
+        val response = client.api.getAlbumList2(STARRED).execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.albumList) {
+            this.size `should be equal to` 2
+            this[0] `should be equal to` Album(
+                id = "962", name = "Fury", artist = "Sick Puppies",
+                artistId = "473", coverArt = "al-962", songCount = 13, duration = 2591,
+                created = parseDate("2017-09-02T17:34:51.000Z"), year = 2016,
+                genre = "Alternative Rock"
+            )
+            this[1] `should be equal to` Album(
+                id = "961", name = "Endless Forms Most Beautiful",
+                artist = "Nightwish", artistId = "559", coverArt = "al-961", songCount = 22,
+                duration = 9469, created = parseDate("2017-09-02T16:22:47.000Z"),
+                year = 2015, genre = "Symphonic Metal"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass type in request params`() {
+        val type = AlbumListType.SORTED_BY_NAME
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_2_ok.json",
+            expectedParam = "type=${type.typeName}"
+        ) {
+            client.api.getAlbumList2(type = type).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass size in request param`() {
+        val size = 45
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_2_ok.json",
+            expectedParam = "size=$size"
+        ) {
+            client.api.getAlbumList2(STARRED, size = size).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass offset in request param`() {
+        val offset = 33
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_2_ok.json",
+            expectedParam = "offset=$offset"
+        ) {
+            client.api.getAlbumList2(STARRED, offset = offset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass from year in request params`() {
+        val fromYear = 3030
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_2_ok.json",
+            expectedParam = "fromYear=$fromYear"
+        ) {
+            client.api.getAlbumList2(STARRED, fromYear = fromYear).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass toYear in request param`() {
+        val toYear = 2014
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_2_ok.json",
+            expectedParam = "toYear=$toYear"
+        ) {
+            client.api.getAlbumList2(STARRED, toYear = toYear).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass genre in request param`() {
+        val genre = "MathRock"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_2_ok.json",
+            expectedParam = "genre=$genre"
+        ) {
+            client.api.getAlbumList2(STARRED, genre = genre).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id in request param`() {
+        val musicFolderId = "9422"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_2_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.getAlbumList2(STARRED, musicFolderId = musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetAlbumListRequestTest.kt

@@ -0,0 +1,124 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Album
+import org.moire.ultrasonic.api.subsonic.models.AlbumListType
+import org.moire.ultrasonic.api.subsonic.models.AlbumListType.BY_GENRE
+
+/**
+ * Integration tests for [SubsonicAPIDefinition] for getAlbumList call.
+ */
+class SubsonicApiGetAlbumListRequestTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getAlbumList(BY_GENRE).execute()
+        }
+
+        response.albumList `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_album_list_ok.json")
+
+        val response = client.api.getAlbumList(BY_GENRE).execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.albumList) {
+            size `should be equal to` 2
+            this[1] `should be equal to` Album(
+                id = "9997", parent = "9996",
+                title = "Endless Forms Most Beautiful", album = "Endless Forms Most Beautiful",
+                artist = "Nightwish", year = 2015, genre = "Symphonic Metal",
+                coverArt = "9997", playCount = 11,
+                created = parseDate("2017-09-02T16:22:49.000Z")
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass type in request params`() {
+        val listType = AlbumListType.HIGHEST
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_ok.json",
+            expectedParam = "type=${listType.typeName}"
+        ) {
+            client.api.getAlbumList(type = listType).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass size in request params`() {
+        val size = 45
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_ok.json",
+            expectedParam = "size=$size"
+        ) {
+            client.api.getAlbumList(type = BY_GENRE, size = size).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass offset in request params`() {
+        val offset = 3
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_ok.json",
+            expectedParam = "offset=$offset"
+        ) {
+            client.api.getAlbumList(type = BY_GENRE, offset = offset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass from year in request params`() {
+        val fromYear = 2001
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_ok.json",
+            expectedParam = "fromYear=$fromYear"
+        ) {
+            client.api.getAlbumList(type = BY_GENRE, fromYear = fromYear).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass to year in request params`() {
+        val toYear = 2017
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_ok.json",
+            expectedParam = "toYear=$toYear"
+        ) {
+            client.api.getAlbumList(type = BY_GENRE, toYear = toYear).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass genre in request params`() {
+        val genre = "Rock"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_ok.json",
+            expectedParam = "genre=$genre"
+        ) {
+            client.api.getAlbumList(type = BY_GENRE, genre = genre).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id in request params`() {
+        val folderId = "545"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_list_ok.json",
+            expectedParam = "musicFolderId=$folderId"
+        ) {
+            client.api.getAlbumList(type = BY_GENRE, musicFolderId = folderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetAlbumTest.kt

@@ -0,0 +1,76 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Album
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIClient] for getAlbum call.
+ */
+class SubsonicApiGetAlbumTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse error responce`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getAlbum("56").execute()
+        }
+
+        response.album `should not be` null
+        response.album `should be equal to` Album()
+    }
+
+    @Test
+    fun `Should add id to request params`() {
+        val id = "76"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_album_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.getAlbum(id).execute()
+        }
+    }
+
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("get_album_ok.json")
+
+        val response = client.api.getAlbum("512").execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.album) {
+            id `should be equal to` "618"
+            name `should be equal to` "Black Ice"
+            artist `should be equal to` "AC/DC"
+            artistId `should be equal to` "362"
+            coverArt `should be equal to` "al-618"
+            songCount `should be equal to` 15
+            duration `should be equal to` 3331
+            created `should be equal to` parseDate("2016-10-23T15:31:22.000Z")
+            year `should be equal to` 2008
+            genre `should be equal to` "Hard Rock"
+            songList.size `should be equal to` 15
+            songList[0] `should be equal to` MusicDirectoryChild(
+                id = "6491", parent = "6475",
+                isDir = false, title = "Rock 'n' Roll Train", album = "Black Ice",
+                artist = "AC/DC", track = 1, year = 2008, genre = "Hard Rock",
+                coverArt = "6475", size = 7205451, contentType = "audio/mpeg", suffix = "mp3",
+                duration = 261, bitRate = 219,
+                path = "AC_DC/Black Ice/01 Rock 'n' Roll Train.mp3",
+                isVideo = false, playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T15:31:20.000Z"),
+                albumId = "618", artistId = "362", type = "music"
+            )
+            songList[5] `should be equal to` MusicDirectoryChild(
+                id = "6492", parent = "6475",
+                isDir = false, title = "Smash 'n' Grab", album = "Black Ice", artist = "AC/DC",
+                track = 6, year = 2008, genre = "Hard Rock", coverArt = "6475", size = 6697204,
+                contentType = "audio/mpeg", suffix = "mp3", duration = 246, bitRate = 216,
+                path = "AC_DC/Black Ice/06 Smash 'n' Grab.mp3", isVideo = false, playCount = 0,
+                discNumber = 1, created = parseDate("2016-10-23T15:31:20.000Z"),
+                albumId = "618", artistId = "362", type = "music"
+            )
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetArtistTest.kt

@@ -0,0 +1,62 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Album
+import org.moire.ultrasonic.api.subsonic.models.Artist
+
+/**
+ * Integration test for [SubsonicAPIClient] for getArtist call.
+ */
+class SubsonicApiGetArtistTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse error call`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getArtist("101").execute()
+        }
+
+        response.artist `should not be` null
+        response.artist `should be equal to` Artist()
+    }
+
+    @Test
+    fun `Should pass id param in request`() {
+        val id = "929"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_artist_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.getArtist(id).execute()
+        }
+    }
+
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("get_artist_ok.json")
+
+        val response = client.api.getArtist("100").execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.artist) {
+            id `should be equal to` "362"
+            name `should be equal to` "AC/DC"
+            coverArt `should be equal to` "ar-362"
+            albumCount `should be equal to` 2
+            albumsList.size `should be equal to` 2
+            albumsList[0] `should be equal to` Album(
+                id = "618", name = "Black Ice", artist = "AC/DC",
+                artistId = "362", coverArt = "al-618", songCount = 15, duration = 3331,
+                created = parseDate("2016-10-23T15:31:22.000Z"),
+                year = 2008, genre = "Hard Rock"
+            )
+            albumsList[1] `should be equal to` Album(
+                id = "617", name = "Rock or Bust", artist = "AC/DC",
+                artistId = "362", coverArt = "al-617", songCount = 11, duration = 2095,
+                created = parseDate("2016-10-23T15:31:23.000Z"),
+                year = 2014, genre = "Hard Rock"
+            )
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetArtistsTest.kt

@@ -0,0 +1,73 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Artist
+import org.moire.ultrasonic.api.subsonic.models.Index
+import org.moire.ultrasonic.api.subsonic.models.Indexes
+
+/**
+ * Integration test for [SubsonicAPIClient] for getArtists() request.
+ */
+class SubsonicApiGetArtistsTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse get artists error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getArtists(null).execute()
+        }
+
+        response.indexes `should not be` null
+        response.indexes `should be equal to` Indexes()
+    }
+
+    @Test
+    fun `Should parse get artists ok reponse`() {
+        mockWebServerRule.enqueueResponse("get_artists_ok.json")
+
+        val response = client.api.getArtists(null).execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.indexes) {
+            lastModified `should be equal to` 0L
+            ignoredArticles `should be equal to` "The El La Los Las Le Les"
+            shortcutList `should be equal to` emptyList()
+            indexList.size `should be equal to` 2
+            indexList `should be equal to` listOf(
+                Index(
+                    name = "A",
+                    artists = listOf(
+                        Artist(id = "362", name = "AC/DC", coverArt = "ar-362", albumCount = 2),
+                        Artist(id = "254", name = "Acceptance", coverArt = "ar-254", albumCount = 1)
+                    )
+                ),
+                Index(
+                    name = "T",
+                    artists = listOf(
+                        Artist(
+                            id = "516", name = "Tangerine Dream", coverArt = "ar-516",
+                            albumCount = 1
+                        ),
+                        Artist(
+                            id = "242", name = "Taproot", coverArt = "ar-242",
+                            albumCount = 2
+                        )
+                    )
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass param on query for get artists call`() {
+        mockWebServerRule.enqueueResponse("get_artists_ok.json")
+        val musicFolderId = "101"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_artists_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.getArtists(musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetAvatarTest.kt

@@ -0,0 +1,66 @@
+package org.moire.ultrasonic.api.subsonic
+
+import okhttp3.mockwebserver.MockResponse
+import org.amshove.kluent.`should be`
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getAvatar] call.
+ */
+class SubsonicApiGetAvatarTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle api error response`() {
+        mockWebServerRule.enqueueResponse("request_data_not_found_error_response.json")
+
+        val response = client.api.getAvatar("some-id").execute().toStreamResponse()
+
+        with(response) {
+            stream `should be` null
+            responseHttpCode `should be equal to` 200
+            apiError `should be equal to` SubsonicError.RequestedDataWasNotFound
+        }
+    }
+
+    @Test
+    fun `Should handle server error`() {
+        val httpErrorCode = 500
+        mockWebServerRule.mockWebServer.enqueue(MockResponse().setResponseCode(httpErrorCode))
+
+        val response = client.api.getAvatar("some-id").execute().toStreamResponse()
+
+        with(response) {
+            stream `should be equal to` null
+            responseHttpCode `should be equal to` httpErrorCode
+            apiError `should be` null
+        }
+    }
+
+    @Test
+    fun `Should return successful call stream`() {
+        mockWebServerRule.mockWebServer.enqueue(
+            MockResponse()
+                .setBody(mockWebServerRule.loadJsonResponse("ping_ok.json"))
+        )
+
+        val response = client.api.stream("some-id").execute().toStreamResponse()
+
+        with(response) {
+            responseHttpCode `should be equal to` 200
+            apiError `should be` null
+            stream `should not be` null
+            val expectedContent = mockWebServerRule.loadJsonResponse("ping_ok.json")
+            stream!!.bufferedReader().readText() `should be equal to` expectedContent
+        }
+    }
+
+    @Test
+    fun `Should pass username as param`() {
+        val username = "Guardian"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "username=$username") {
+            client.api.getAvatar(username).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetBookmarksTest.kt

@@ -0,0 +1,47 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getBookmarks] call.
+ */
+class SubsonicApiGetBookmarksTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getBookmarks().execute()
+        }
+
+        response.bookmarkList `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_bookmarks_ok.json")
+
+        val response = client.api.getBookmarks().execute()
+
+        assertResponseSuccessful(response)
+        response.body()!!.bookmarkList.size `should be equal to` 1
+        with(response.body()!!.bookmarkList[0]) {
+            position `should be equal to` 107914
+            username `should be equal to` "CaptainEurope"
+            comment `should be equal to` "Look at this"
+            created `should be equal to` parseDate("2017-11-18T15:22:22.144Z")
+            changed `should be equal to` parseDate("2017-11-18T15:22:22.144Z")
+            entry `should be equal to` MusicDirectoryChild(
+                id = "10349", parent = "10342",
+                isDir = false, title = "Amerika", album = "Home of the Strange",
+                artist = "Young the Giant", track = 1, year = 2016, genre = "Indie Rock",
+                coverArt = "10342", size = 9628673, contentType = "audio/mpeg",
+                suffix = "mp3", duration = 240, bitRate = 320,
+                path = "Young the Giant/Home of the Strange/01 Amerika.mp3",
+                isVideo = false, playCount = 2, discNumber = 1,
+                created = parseDate("2017-11-01T17:46:52.000Z"),
+                albumId = "984", artistId = "571", type = "music"
+            )
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetChatMessagesTest.kt

@@ -0,0 +1,48 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.ChatMessage
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getChatMessages] call.
+ */
+class SubsonicApiGetChatMessagesTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getChatMessages().execute()
+        }
+
+        response.chatMessages `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_chat_messages_ok.json")
+
+        val response = client.api.getChatMessages().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.chatMessages) {
+            size `should be equal to` 2
+            this[0] `should be equal to` ChatMessage(
+                username = "sindre", time = 1269771845310,
+                message = "Sindre was here"
+            )
+            this[1] `should be equal to` ChatMessage(
+                username = "ben", time = 1269771842504,
+                message = "Ben too"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass since in request param`() {
+        val since = 21388L
+
+        mockWebServerRule.assertRequestParam(expectedParam = "since=$since") {
+            client.api.getChatMessages(since = since).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetCoverArtTest.kt

@@ -0,0 +1,75 @@
+package org.moire.ultrasonic.api.subsonic
+
+import okhttp3.mockwebserver.MockResponse
+import org.amshove.kluent.`should be`
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] for [SubsonicAPIDefinition.getCoverArt] call.
+ */
+class SubsonicApiGetCoverArtTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle api error response`() {
+        mockWebServerRule.enqueueResponse("request_data_not_found_error_response.json")
+
+        val response = client.api.getCoverArt("some-id").execute().toStreamResponse()
+
+        with(response) {
+            stream `should be` null
+            responseHttpCode `should be equal to` 200
+            apiError `should be equal to` SubsonicError.RequestedDataWasNotFound
+        }
+    }
+
+    @Test
+    fun `Should handle server error`() {
+        val httpErrorCode = 404
+        mockWebServerRule.mockWebServer.enqueue(MockResponse().setResponseCode(httpErrorCode))
+
+        val response = client.api.getCoverArt("some-id").execute().toStreamResponse()
+
+        with(response) {
+            stream `should be` null
+            responseHttpCode `should be equal to` 404
+            apiError `should be` null
+        }
+    }
+
+    @Test
+    fun `Should return successful call stream`() {
+        mockWebServerRule.mockWebServer.enqueue(
+            MockResponse()
+                .setBody(mockWebServerRule.loadJsonResponse("ping_ok.json"))
+        )
+
+        val response = client.api.getCoverArt("some-id").execute().toStreamResponse()
+
+        with(response) {
+            responseHttpCode `should be equal to` 200
+            apiError `should be` null
+            stream `should not be` null
+            val expectedContent = mockWebServerRule.loadJsonResponse("ping_ok.json")
+            stream!!.bufferedReader().readText() `should be equal to` expectedContent
+        }
+    }
+
+    @Test
+    fun `Should pass id as parameter`() {
+        val id = "ca123994"
+
+        mockWebServerRule.assertRequestParam("ping_ok.json", id) {
+            client.api.getCoverArt(id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass size as a parameter`() {
+        val size = 45600L
+
+        mockWebServerRule.assertRequestParam("ping_ok.json", size.toString()) {
+            client.api.getCoverArt("some-id", size).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetGenresTest.kt

@@ -0,0 +1,36 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Genre
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getGenres] call.
+ */
+class SubsonicApiGetGenresTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getGenres().execute()
+        }
+
+        response.genresList `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_genres_ok.json")
+
+        val response = client.api.getGenres().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.genresList) {
+            size `should be equal to` 5
+            this[0] `should be equal to` Genre(1186, 103, "Rock")
+            this[1] `should be equal to` Genre(896, 72, "Electronic")
+            this[2] `should be equal to` Genre(790, 59, "Alternative Rock")
+            this[3] `should be equal to` Genre(622, 97, "Trance")
+            this[4] `should be equal to` Genre(476, 36, "Hard Rock")
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetIndexesTest.kt

@@ -0,0 +1,84 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Artist
+import org.moire.ultrasonic.api.subsonic.models.Index
+import org.moire.ultrasonic.api.subsonic.models.Indexes
+
+/**
+ * Integration test for [SubsonicAPIClient] for getIndexes() request.
+ */
+class SubsonicApiGetIndexesTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse get indexes ok response`() {
+        mockWebServerRule.enqueueResponse("get_indexes_ok.json")
+
+        val response = client.api.getIndexes(null, null).execute()
+
+        assertResponseSuccessful(response)
+        response.body()!!.indexes `should not be` null
+        with(response.body()!!.indexes) {
+            lastModified `should be equal to` 1491069027523
+            ignoredArticles `should be equal to` "The El La Los Las Le Les"
+            shortcutList `should be equal to` listOf(
+                Artist(id = "889", name = "podcasts"),
+                Artist(id = "890", name = "audiobooks")
+            )
+            indexList `should be equal to` mutableListOf(
+                Index(
+                    "A",
+                    listOf(
+                        Artist(
+                            id = "50", name = "Ace Of Base",
+                            starred = parseDate("2017-04-02T20:16:29.815Z")
+                        ),
+                        Artist(id = "379", name = "A Perfect Circle")
+                    )
+                ),
+                Index(
+                    "H",
+                    listOf(
+                        Artist(id = "299", name = "Haddaway"),
+                        Artist(id = "297", name = "Halestorm")
+                    )
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `Should add music folder id as a query param for getIndexes api call`() {
+        val musicFolderId = "9"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_indexes_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.getIndexes(musicFolderId, null).execute()
+        }
+    }
+
+    @Test
+    fun `Should add ifModifiedSince as a query param for getIndexes api call`() {
+        val ifModifiedSince = System.currentTimeMillis()
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_indexes_ok.json",
+            expectedParam = "ifModifiedSince=$ifModifiedSince"
+        ) {
+            client.api.getIndexes(null, ifModifiedSince).execute()
+        }
+    }
+
+    @Test
+    fun `Should parse get indexes error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getIndexes(null, null).execute()
+        }
+
+        response.indexes `should not be` null
+        response.indexes `should be equal to` Indexes()
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetLicenseTest.kt

@@ -0,0 +1,40 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.License
+
+/**
+ * Integration test [SubsonicAPIClient] for getLicense() request.
+ */
+class SubsonicApiGetLicenseTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse get license ok response`() {
+        mockWebServerRule.enqueueResponse("license_ok.json")
+
+        val response = client.api.getLicense().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!) {
+            assertBaseResponseOk()
+            license `should be equal to` License(
+                valid = true,
+                trialExpires = parseDate("2016-11-23T20:17:15.206Z"),
+                email = "someone@example.net",
+                licenseExpires = parseDate("8994-08-17T07:12:55.807Z")
+            )
+        }
+    }
+
+    @Test
+    fun `Should parse get license error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getLicense().execute()
+        }
+
+        response.license `should not be` null
+        response.license.email `should be equal to` License().email
+        response.license.valid `should be equal to` License().valid
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetLyricsTest.kt

@@ -0,0 +1,55 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] for getLyrics() call.
+ */
+class SubsonicApiGetLyricsTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.getLyrics().execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_lyrics_ok.json")
+
+        val response = client.api.getLyrics().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.lyrics) {
+            artist `should be equal to` "Amorphis"
+            title `should be equal to` "Alone"
+            text `should be equal to` "Tear dimmed rememberance\nIn a womb of time\nBreath upon " +
+                "me\nPossessed by the"
+        }
+    }
+
+    @Test
+    fun `Should pass artist param in request`() {
+        val artist = "some-artist"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_lyrics_ok.json",
+            expectedParam = "artist=$artist"
+        ) {
+            client.api.getLyrics(artist = artist).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass title param in request`() {
+        val title = "some-title"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_lyrics_ok.json",
+            expectedParam = "title=$title"
+        ) {
+            client.api.getLyrics(title = title).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetMusicDirectoryTest.kt

@@ -0,0 +1,76 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be`
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectory
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIClient] for getMusicDirectory request.
+ */
+class SubsonicApiGetMusicDirectoryTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse getMusicDirectory error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getMusicDirectory("1").execute()
+        }
+
+        response.musicDirectory `should not be` null
+        response.musicDirectory `should be equal to` MusicDirectory()
+    }
+
+    @Test
+    fun `GetMusicDirectory should add directory id to query params`() {
+        val directoryId = "124"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_music_directory_ok.json",
+            expectedParam = "id=$directoryId"
+        ) {
+            client.api.getMusicDirectory(directoryId).execute()
+        }
+    }
+
+    @Test
+    fun `Should parse get music directory ok response`() {
+        mockWebServerRule.enqueueResponse("get_music_directory_ok.json")
+
+        val response = client.api.getMusicDirectory("1").execute()
+
+        assertResponseSuccessful(response)
+
+        response.body()!!.musicDirectory `should not be` null
+        with(response.body()!!.musicDirectory) {
+            id `should be equal to` "4836"
+            parent `should be equal to` "300"
+            name `should be equal to` "12 Stones"
+            userRating `should be equal to` 5
+            averageRating `should be equal to` 5.0f
+            starred `should be equal to` null
+            playCount `should be equal to` 1
+            childList.size `should be` 2
+            childList[0] `should be equal to` MusicDirectoryChild(
+                id = "4844", parent = "4836",
+                isDir = false, title = "Crash", album = "12 Stones", artist = "12 Stones",
+                track = 1, year = 2002, genre = "Alternative Rock", coverArt = "4836",
+                size = 5348318L, contentType = "audio/mpeg", suffix = "mp3", duration = 222,
+                bitRate = 192, path = "12 Stones/12 Stones/01 Crash.mp3", isVideo = false,
+                playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T15:19:10.000Z"),
+                albumId = "454", artistId = "288", type = "music"
+            )
+            childList[1] `should be equal to` MusicDirectoryChild(
+                id = "4845", parent = "4836",
+                isDir = false, title = "Broken", album = "12 Stones", artist = "12 Stones",
+                track = 2, year = 2002, genre = "Alternative Rock", coverArt = "4836",
+                size = 4309043L, contentType = "audio/mpeg", suffix = "mp3", duration = 179,
+                bitRate = 192, path = "12 Stones/12 Stones/02 Broken.mp3", isVideo = false,
+                playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T15:19:09.000Z"),
+                albumId = "454", artistId = "288", type = "music"
+            )
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetMusicFoldersTest.kt

@@ -0,0 +1,35 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicFolder
+
+/**
+ * Integration test for [SubsonicAPIClient] for getMusicFolders() request.
+ */
+class SubsonicApiGetMusicFoldersTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse get music folders ok response`() {
+        mockWebServerRule.enqueueResponse("get_music_folders_ok.json")
+
+        val response = client.api.getMusicFolders().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!) {
+            assertBaseResponseOk()
+            musicFolders `should be equal to` listOf(
+                MusicFolder("0", "Music"),
+                MusicFolder("2", "Test")
+            )
+        }
+    }
+
+    @Test
+    fun `Should parse get music folders error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getMusicFolders().execute()
+        }
+
+        response.musicFolders `should be equal to` emptyList()
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetPlaylistTest.kt

@@ -0,0 +1,66 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+import org.moire.ultrasonic.api.subsonic.models.Playlist
+
+/**
+ * Integration test for [SubsonicAPIClient] for getPlaylist call.
+ */
+class SubsonicApiGetPlaylistTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getPlaylist("10").execute()
+        }
+
+        response.playlist `should not be` null
+        response.playlist `should be equal to` Playlist()
+    }
+
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("get_playlist_ok.json")
+
+        val response = client.api.getPlaylist("4").execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.playlist) {
+            id `should be equal to` "0"
+            name `should be equal to` "Aug 27, 2017 11:17 AM"
+            owner `should be equal to` "admin"
+            public `should be equal to` false
+            songCount `should be equal to` 16
+            duration `should be equal to` 3573
+            created `should be equal to` parseDate("2017-08-27T11:17:26.216Z")
+            changed `should be equal to` parseDate("2017-08-27T11:17:26.218Z")
+            coverArt `should be equal to` "pl-0"
+            entriesList.size `should be equal to` 2
+            entriesList[1] `should be equal to` MusicDirectoryChild(
+                id = "4215", parent = "4186",
+                isDir = false, title = "Going to Hell", album = "Going to Hell",
+                artist = "The Pretty Reckless", track = 2, year = 2014,
+                genre = "Hard Rock", coverArt = "4186", size = 11089627,
+                contentType = "audio/mpeg", suffix = "mp3", duration = 277, bitRate = 320,
+                path = "The Pretty Reckless/Going to Hell/02 Going to Hell.mp3",
+                isVideo = false, playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T21:30:41.000Z"),
+                albumId = "388", artistId = "238", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass id as request param`() {
+        val playlistId = "453"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_playlist_ok.json",
+            expectedParam = "id=$playlistId"
+        ) {
+            client.api.getPlaylist(playlistId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetPlaylistsTest.kt

@@ -0,0 +1,53 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Playlist
+
+/**
+ * Integration test for [SubsonicAPIClient] for getPlaylists call.
+ */
+class SubsonicApiGetPlaylistsTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse error call`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getPlaylists().execute()
+        }
+
+        response.playlists `should not be` null
+        response.playlists `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("get_playlists_ok.json")
+
+        val response = client.api.getPlaylists().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.playlists) {
+            size `should be equal to` 1
+            this[0] `should be equal to` Playlist(
+                id = "0", name = "Aug 27, 2017 11:17 AM",
+                owner = "admin", public = false, songCount = 16, duration = 3573,
+                comment = "Some comment",
+                created = parseDate("2017-08-27T11:17:26.216Z"),
+                changed = parseDate("2017-08-27T11:17:26.218Z"),
+                coverArt = "pl-0"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass username as a parameter`() {
+        val username = "SomeUsername"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_playlists_ok.json",
+            expectedParam = "username=$username"
+        ) {
+            client.api.getPlaylists(username = username).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetPodcastsTest.kt

@@ -0,0 +1,91 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIClient] for getPodcasts call.
+ */
+class SubsonicApiGetPodcastsTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getPodcasts().execute()
+        }
+
+        response.podcastChannels `should not be` null
+        response.podcastChannels `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_podcasts_ok.json")
+
+        val response = client.api.getPodcasts().execute()
+
+        assertResponseSuccessful(response)
+        val podcastChannelsList = response.body()!!.podcastChannels
+        podcastChannelsList.size `should be equal to` 1
+        with(podcastChannelsList[0]) {
+            id `should be equal to` "2"
+            url `should be equal to` "http://feeds.codenewbie.org/cnpodcast.xml"
+            title `should be equal to` "CodeNewbie"
+            description `should be equal to` "Stories and interviews from people on their coding " +
+                "journey."
+            coverArt `should be equal to` "pod-2"
+            originalImageUrl `should be equal to` "http://codenewbie.blubrry.com/wp-content/" +
+                "uploads/powerpress/220808.jpg"
+            status `should be equal to` "completed"
+            errorMessage `should be equal to` ""
+            episodeList.size `should be equal to` 10
+            episodeList[0] `should be equal to` MusicDirectoryChild(
+                id = "148", parent = "9959",
+                isDir = false,
+                title = "S1:EP3 – How to teach yourself computer science (Vaidehi Joshi)",
+                album = "CodeNewbie", artist = "podcasts", coverArt = "9959",
+                size = 38274221, contentType = "audio/mpeg", suffix = "mp3",
+                duration = 2397, bitRate = 128, isVideo = false, playCount = 0,
+                created = parseDate("2017-08-30T09:33:39.000Z"), type = "podcast",
+                streamId = "9982", channelId = "2",
+                description = "Vaidehi decided to take on a year-long challenge. " +
+                    "She'd pick a computer science topic every week, do tons of research " +
+                    "and write a technical blog post explaining it in simple terms and " +
+                    "beautiful illustrations. And then she actually did it. She tells us " +
+                    "about her project, basecs, how it's changed her as a developer, and " +
+                    "how she handles the trolls and negativity from people who don't " +
+                    "appreciate her work. Show Notes Technical Writer position at " +
+                    "CodeNewbie basecs 100 Days of Code Conway's Game of Life Hexes and " +
+                    "Other Magical Numbers (Vaidehi's blog post) Bits, Bytes, Building " +
+                    "With Binary (Vaidehi's blog post) Rust",
+                status = "completed",
+                publishDate = parseDate("2017-08-29T00:01:01.000Z")
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass include episodes in request`() {
+        val includeEpisodes = true
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_podcasts_ok.json",
+            expectedParam = "includeEpisodes=$includeEpisodes"
+        ) {
+            client.api.getPodcasts(includeEpisodes = includeEpisodes).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass id in request param`() {
+        val id = "249"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_podcasts_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.getPodcasts(id = id).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetRandomSongsTest.kt

@@ -0,0 +1,101 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIClient] for getRandomSongs call.
+ */
+class SubsonicApiGetRandomSongsTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getRandomSongs().execute()
+        }
+
+        response.songsList `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_random_songs_ok.json")
+
+        val response = client.api.getRandomSongs().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.songsList) {
+            size `should be equal to` 3
+            this[1] `should be equal to` MusicDirectoryChild(
+                id = "3061", parent = "3050", isDir = false,
+                title = "Sure as Hell", album = "Who Are You Now?", artist = "This Providence",
+                track = 1, year = 2009, genre = "Indie Rock", coverArt = "3050",
+                size = 1969692, contentType = "audio/mpeg", suffix = "mp3", duration = 110,
+                bitRate = 142, path = "This Providence/Who Are You Now_/01 Sure as Hell.mp3",
+                isVideo = false, playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T21:32:46.000Z"), albumId = "272",
+                artistId = "152", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass size in request param`() {
+        val size = 384433
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_random_songs_ok.json",
+            expectedParam = "size=$size"
+        ) {
+            client.api.getRandomSongs(size = size).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass genre in request param`() {
+        val genre = "PostRock"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_random_songs_ok.json",
+            expectedParam = "genre=$genre"
+        ) {
+            client.api.getRandomSongs(genre = genre).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass from year in request param`() {
+        val fromYear = 1919
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_random_songs_ok.json",
+            expectedParam = "fromYear=$fromYear"
+        ) {
+            client.api.getRandomSongs(fromYear = fromYear).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass to year in request params`() {
+        val toYear = 2012
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_random_songs_ok.json",
+            expectedParam = "toYear=$toYear"
+        ) {
+            client.api.getRandomSongs(toYear = toYear).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id in request param`() {
+        val musicFolderId = "4919"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_random_songs_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.getRandomSongs(musicFolderId = musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetSharesTest.kt

@@ -0,0 +1,51 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getShares] call.
+ */
+class SubsonicApiGetSharesTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getShares().execute()
+        }
+
+        response.shares `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_shares_ok.json")
+
+        val response = client.api.getShares().execute()
+
+        assertResponseSuccessful(response)
+        response.body()!!.shares.size `should be equal to` 1
+        with(response.body()!!.shares[0]) {
+            id `should be equal to` "0"
+            url `should be equal to` "https://subsonic.com/ext/share/awdwo?jwt=eyJhbGciOiJIUzI1" +
+                "NiJ9.eyJwYXRoIjoiL2V4dC9zaGFyZS9hd2R3byIsImV4cCI6MTU0MTYyNjQzMX0.iy8dkt_ZZc8" +
+                "hJ692UxorHdHWFU2RB-fMCmCA4IJ_dTw"
+            username `should be equal to` "admin"
+            created `should be equal to` parseDate("2017-11-07T21:33:51.748Z")
+            expires `should be equal to` parseDate("2018-11-07T21:33:51.748Z")
+            lastVisited `should be equal to` parseDate("2018-11-07T21:33:51.748Z")
+            visitCount `should be equal to` 0
+            description `should be equal to` "Awesome link!"
+            items.size `should be equal to` 1
+            items[0] `should be equal to` MusicDirectoryChild(
+                id = "4212", parent = "4186", isDir = false,
+                title = "Heaven Knows", album = "Going to Hell", artist = "The Pretty Reckless",
+                track = 3, year = 2014, genre = "Hard Rock", coverArt = "4186", size = 9025090,
+                contentType = "audio/mpeg", suffix = "mp3", duration = 225, bitRate = 320,
+                path = "The Pretty Reckless/Going to Hell/03 Heaven Knows.mp3", isVideo = false,
+                playCount = 2, discNumber = 1, created = parseDate("2016-10-23T21:30:40.000Z"),
+                albumId = "388", artistId = "238", type = "music"
+            )
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetSongsByGenreTest.kt

@@ -0,0 +1,87 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getSongsByGenre] call.
+ */
+class SubsonicApiGetSongsByGenreTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getSongsByGenre("Metal").execute()
+        }
+
+        response.songsList `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_songs_by_genre_ok.json")
+
+        val response = client.api.getSongsByGenre("Trance").execute()
+
+        assertResponseSuccessful(response)
+        response.body()!!.songsList.size `should be equal to` 2
+        with(response.body()!!.songsList) {
+            this[0] `should be equal to` MusicDirectoryChild(
+                id = "575", parent = "576", isDir = false,
+                title = "Time Machine (Vadim Zhukov Remix)", album = "668",
+                artist = "Tasadi", year = 2008, genre = "Trance", size = 22467672,
+                contentType = "audio/mpeg", suffix = "mp3", duration = 561, bitRate = 320,
+                path = "Tasadi/668/00 Time Machine (Vadim Zhukov Remix).mp3",
+                isVideo = false, playCount = 0, created = parseDate("2016-10-23T21:58:29.000Z"),
+                albumId = "0", artistId = "0", type = "music"
+            )
+            this[1] `should be equal to` MusicDirectoryChild(
+                id = "621", parent = "622", isDir = false,
+                title = "My Heart (Vadim Zhukov Remix)", album = "668",
+                artist = "DJ Polyakov PPK Feat Kate Cameron", year = 2009, genre = "Trance",
+                size = 26805932, contentType = "audio/mpeg", suffix = "mp3", duration = 670,
+                bitRate = 320,
+                path = "DJ Polyakov PPK Feat Kate Cameron/668/00 My Heart (Vadim Zhukov " +
+                    "Remix).mp3",
+                isVideo = false, playCount = 2,
+                created = parseDate("2016-10-23T21:58:29.000Z"),
+                albumId = "5", artistId = "4", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass genre in request param`() {
+        val genre = "Rock"
+        mockWebServerRule.assertRequestParam(expectedParam = "genre=$genre") {
+            client.api.getSongsByGenre(genre = genre).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass count in request param`() {
+        val count = 494
+
+        mockWebServerRule.assertRequestParam(expectedParam = "count=$count") {
+            client.api.getSongsByGenre("Trance", count = count).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass offset in request param`() {
+        val offset = 31
+
+        mockWebServerRule.assertRequestParam(expectedParam = "offset=$offset") {
+            client.api.getSongsByGenre("Trance", offset = offset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id in request param`() {
+        val musicFolderId = "1010"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "musicFolderId=$musicFolderId") {
+            client.api.getSongsByGenre("Trance", musicFolderId = musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetStarred2Test.kt

@@ -0,0 +1,51 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Artist
+import org.moire.ultrasonic.api.subsonic.models.SearchTwoResult
+
+/**
+ * Integration test for [SubsonicAPIClient] for getStarred2 call.
+ */
+@Suppress("NamingConventionViolation")
+class SubsonicApiGetStarred2Test : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getStarred2().execute()
+        }
+
+        response.starred2 `should be equal to` SearchTwoResult()
+    }
+
+    @Test
+    fun `Should handle ok reponse`() {
+        mockWebServerRule.enqueueResponse("get_starred_2_ok.json")
+
+        val response = client.api.getStarred2().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.starred2) {
+            albumList `should be equal to` emptyList()
+            artistList.size `should be equal to` 1
+            artistList[0] `should be equal to` Artist(
+                id = "364", name = "Parov Stelar",
+                starred = parseDate("2017-08-12T18:32:58.768Z")
+            )
+            songList `should be equal to` emptyList()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id in request param`() {
+        val musicFolderId = "441"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_starred_2_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.getStarred2(musicFolderId = musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetStarredTest.kt

@@ -0,0 +1,50 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Artist
+import org.moire.ultrasonic.api.subsonic.models.SearchTwoResult
+
+/**
+ * Integration test for [SubsonicAPIClient] for getStarred call.
+ */
+class SubsonicApiGetStarredTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getStarred().execute()
+        }
+
+        response.starred `should be equal to` SearchTwoResult()
+    }
+
+    @Test
+    fun `Should handle ok reponse`() {
+        mockWebServerRule.enqueueResponse("get_starred_ok.json")
+
+        val response = client.api.getStarred().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.starred) {
+            albumList `should be equal to` emptyList()
+            artistList.size `should be equal to` 1
+            artistList[0] `should be equal to` Artist(
+                id = "364", name = "Parov Stelar",
+                starred = parseDate("2017-08-12T18:32:58.768Z")
+            )
+            songList `should be equal to` emptyList()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id in request param`() {
+        val musicFolderId = "441"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "get_starred_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.getStarred(musicFolderId = musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetUserTest.kt

@@ -0,0 +1,56 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.User
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getUser] call.
+ */
+class SubsonicApiGetUserTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getUser("some").execute()
+        }
+
+        response.user `should be equal to` User()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_user_ok.json")
+
+        val response = client.api.getUser("some").execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.user) {
+            username `should be equal to` "GodOfUniverse"
+            email `should be equal to` "some.mail@example.com"
+            scrobblingEnabled `should be equal to` false
+            adminRole `should be equal to` true
+            settingsRole `should be equal to` true
+            downloadRole `should be equal to` true
+            uploadRole `should be equal to` true
+            playlistRole `should be equal to` true
+            coverArtRole `should be equal to` true
+            commentRole `should be equal to` true
+            podcastRole `should be equal to` true
+            streamRole `should be equal to` true
+            jukeboxRole `should be equal to` true
+            shareRole `should be equal to` true
+            videoConverstionRole `should be equal to` false
+            folderList.size `should be equal to` 1
+            folderList[0] `should be equal to` 0
+        }
+    }
+
+    @Test
+    fun `Should pass username in request param`() {
+        val username = "Mighty"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "username=$username") {
+            client.api.getUser(username).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiGetVideosListTest.kt

@@ -0,0 +1,40 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIDefinition.getVideos] call.
+ */
+class SubsonicApiGetVideosListTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.getVideos().execute()
+        }
+
+        response.videosList `should be equal to` emptyList()
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("get_videos_ok.json")
+
+        val response = client.api.getVideos().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.videosList) {
+            size `should be equal to` 1
+            this[0] `should be equal to` MusicDirectoryChild(
+                id = "10402", parent = "10401",
+                isDir = false, title = "MVI_0512", album = "Incoming", size = 21889646,
+                contentType = "video/avi", suffix = "avi",
+                transcodedContentType = "video/x-flv", transcodedSuffix = "flv",
+                path = "Incoming/MVI_0512.avi", isVideo = true,
+                playCount = 0, created = parseDate("2017-11-19T12:34:33.000Z"),
+                type = "video"
+            )
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiJukeboxControlTest.kt

@@ -0,0 +1,111 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.JukeboxAction
+import org.moire.ultrasonic.api.subsonic.models.JukeboxAction.GET
+import org.moire.ultrasonic.api.subsonic.models.JukeboxAction.STATUS
+import org.moire.ultrasonic.api.subsonic.models.JukeboxStatus
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+
+/**
+ * Integration test for [SubsonicAPIDefinition.jukeboxControl] call.
+ */
+class SubsonicApiJukeboxControlTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.jukeboxControl(GET).execute()
+        }
+
+        response.jukebox `should be equal to` JukeboxStatus()
+    }
+
+    @Test
+    fun `Should handle ok response with jukebox status`() {
+        mockWebServerRule.enqueueResponse("jukebox_control_status_ok.json")
+
+        val response = client.api.jukeboxControl(STATUS).execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.jukebox) {
+            currentIndex `should be equal to` 94
+            playing `should be equal to` true
+            gain `should be equal to` 0.32f
+            position `should be equal to` 3
+            playlistEntries `should be equal to` emptyList()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response with jukebox playlist`() {
+        mockWebServerRule.enqueueResponse("jukebox_control_playlist_ok.json")
+
+        val response = client.api.jukeboxControl(GET).execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.jukebox) {
+            currentIndex `should be equal to` 887
+            playing `should be equal to` false
+            gain `should be equal to` 0.88f
+            position `should be equal to` 2
+            playlistEntries.size `should be equal to` 2
+            playlistEntries[1] `should be equal to` MusicDirectoryChild(
+                id = "4215", parent = "4186",
+                isDir = false, title = "Going to Hell", album = "Going to Hell",
+                artist = "The Pretty Reckless", track = 2, year = 2014, genre = "Hard Rock",
+                coverArt = "4186", size = 11089627, contentType = "audio/mpeg",
+                suffix = "mp3", duration = 277, bitRate = 320,
+                path = "The Pretty Reckless/Going to Hell/02 Going to Hell.mp3",
+                isVideo = false, playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T21:30:41.000Z"), albumId = "388",
+                artistId = "238", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass action in request params`() {
+        val action = JukeboxAction.SET_GAIN
+
+        mockWebServerRule.assertRequestParam(expectedParam = "action=$action") {
+            client.api.jukeboxControl(action).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass index in request params`() {
+        val index = 440
+
+        mockWebServerRule.assertRequestParam(expectedParam = "index=$index") {
+            client.api.jukeboxControl(GET, index = index).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass offset in request params`() {
+        val offset = 58223
+
+        mockWebServerRule.assertRequestParam(expectedParam = "offset=$offset") {
+            client.api.jukeboxControl(GET, offset = offset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass ids in request params`() {
+        val id = listOf("some-id1", "some-id2")
+
+        mockWebServerRule.assertRequestParam(expectedParam = "id=${id[0]}&id=${id[1]}") {
+            client.api.jukeboxControl(GET, ids = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass gain in request params`() {
+        val gain = 0.73f
+
+        mockWebServerRule.assertRequestParam(expectedParam = "gain=$gain") {
+            client.api.jukeboxControl(GET, gain = gain).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiPasswordTest.kt

@@ -0,0 +1,42 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should contain`
+import org.amshove.kluent.`should not contain`
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] that checks proper user password handling.
+ */
+class SubsonicApiPasswordTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should pass PasswordMD5Interceptor in query params for api version 1 13 0`() {
+        val clientV12 = SubsonicAPIClient(
+            config.copy(minimalProtocolVersion = SubsonicAPIVersions.V1_14_0)
+        )
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        clientV12.api.ping().execute()
+
+        with(mockWebServerRule.mockWebServer.takeRequest()) {
+            requestLine `should contain` "&s="
+            requestLine `should contain` "&t="
+            requestLine `should not contain` "&p=enc:"
+        }
+    }
+
+    @Test
+    fun `Should pass PasswordHexInterceptor in query params for api version 1 12 0`() {
+        val clientV11 = SubsonicAPIClient(
+            config.copy(minimalProtocolVersion = SubsonicAPIVersions.V1_12_0)
+        )
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        clientV11.api.ping().execute()
+
+        with(mockWebServerRule.mockWebServer.takeRequest()) {
+            requestLine `should not contain` "&s="
+            requestLine `should not contain` "&t="
+            requestLine `should contain` "&p=enc:"
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiPingRequestTest.kt

@@ -0,0 +1,27 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] that checks ping api call.
+ */
+class SubsonicApiPingRequestTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse ping ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.ping().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!) {
+            assertBaseResponseOk()
+        }
+    }
+
+    @Test
+    fun `Should parse ping error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.ping().execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiSSLTest.kt

@@ -0,0 +1,109 @@
+package org.moire.ultrasonic.api.subsonic
+
+import java.io.InputStream
+import java.net.InetAddress
+import java.security.KeyStore
+import java.security.cert.CertificateFactory
+import java.security.cert.X509Certificate
+import javax.net.ssl.KeyManagerFactory
+import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLHandshakeException
+import javax.net.ssl.TrustManagerFactory
+import okhttp3.mockwebserver.MockWebServer
+import org.amshove.kluent.`should throw`
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+
+private const val PORT = 8443
+private const val HOST = "localhost"
+
+/**
+ * Integration test to check [SubsonicAPIClient] interaction with different SSL scenarios.
+ */
+class SubsonicApiSSLTest {
+    private val mockWebServer = MockWebServer()
+
+    @Before
+    fun setUp() {
+        val sslContext = createSSLContext(
+            loadResourceStream("self-signed.pem"),
+            loadResourceStream("self-signed.p12"),
+            ""
+        )
+        mockWebServer.useHttps(sslContext.socketFactory, false)
+        mockWebServer.start(InetAddress.getByName(HOST), PORT)
+    }
+
+    @After
+    fun tearDown() {
+        mockWebServer.shutdown()
+    }
+
+    private fun createSSLContext(
+        certificatePemStream: InputStream,
+        certificatePkcs12Stream: InputStream,
+        password: String
+    ): SSLContext {
+        var cert: X509Certificate?
+        val trustStore = KeyStore.getInstance(KeyStore.getDefaultType())
+        trustStore.load(null)
+
+        certificatePemStream.use {
+            cert = (
+                CertificateFactory.getInstance("X.509")
+                    .generateCertificate(certificatePemStream)
+                ) as X509Certificate
+        }
+        val alias = cert?.subjectX500Principal?.name
+            ?: throw IllegalStateException("Failed to load certificate")
+        trustStore.setCertificateEntry(alias, cert)
+
+        val tmf = TrustManagerFactory.getInstance("X509")
+        tmf.init(trustStore)
+        val trustManagers = tmf.trustManagers
+        val sslContext = SSLContext.getInstance("TLS")
+
+        val ks = KeyStore.getInstance("PKCS12")
+        ks.load(certificatePkcs12Stream, password.toCharArray())
+        val kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
+        kmf.init(ks, password.toCharArray())
+
+        sslContext.init(kmf.keyManagers, trustManagers, null)
+        return sslContext
+    }
+
+    @Test
+    fun `Should fail request if self-signed certificate support is disabled`() {
+        val client = createSubsonicClient(false)
+        mockWebServer.enqueueResponse("ping_ok.json")
+
+        val fail = {
+            client.api.ping().execute()
+        }
+
+        fail `should throw` SSLHandshakeException::class
+    }
+
+    @Test
+    fun `Should pass request if self-signed certificate support is enabled`() {
+        val client = createSubsonicClient(true)
+        mockWebServer.enqueueResponse("ping_ok.json")
+
+        val response = client.api.ping().execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    private fun createSubsonicClient(allowSelfSignedCertificate: Boolean): SubsonicAPIClient {
+        val config = SubsonicClientConfiguration(
+            "https://$HOST:$PORT/",
+            USERNAME,
+            PASSWORD,
+            CLIENT_VERSION,
+            CLIENT_ID,
+            allowSelfSignedCertificate = allowSelfSignedCertificate
+        )
+        return SubsonicAPIClient(config)
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiScrobbleTest.kt

@@ -0,0 +1,61 @@
+package org.moire.ultrasonic.api.subsonic
+
+import java.util.Calendar
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] for scrobble call.
+ */
+class SubsonicApiScrobbleTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.scrobble("id").execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.scrobble("id").execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass id param in request`() {
+        val id = "some-id"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.scrobble(id = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass time param in request`() {
+        val time = Calendar.getInstance().timeInMillis
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "time=$time"
+        ) {
+            client.api.scrobble(id = "some-id", time = time).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass submission param in request`() {
+        val submission = false
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "submission=$submission"
+        ) {
+            client.api.scrobble(id = "some-id", submission = submission).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiSearchTest.kt

@@ -0,0 +1,134 @@
+package org.moire.ultrasonic.api.subsonic
+
+import java.util.Calendar
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+import org.moire.ultrasonic.api.subsonic.models.SearchResult
+
+/**
+ * Integration test for [SubsonicAPIClient] for search call.
+ */
+class SubsonicApiSearchTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.search().execute()
+        }
+
+        response.searchResult `should not be` null
+        response.searchResult `should be equal to` SearchResult()
+    }
+
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("search_ok.json")
+
+        val response = client.api.search().execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.searchResult) {
+            offset `should be equal to` 10
+            totalHits `should be equal to` 53
+            matchList.size `should be equal to` 1
+            matchList[0] `should be equal to` MusicDirectoryChild(
+                id = "5831", parent = "5766",
+                isDir = false, title = "You'll Be Under My Wheels",
+                album = "Need for Speed Most Wanted", artist = "The Prodigy",
+                track = 17, year = 2005, genre = "Rap", coverArt = "5766",
+                size = 5607024, contentType = "audio/mpeg", suffix = "mp3", duration = 233,
+                bitRate = 192,
+                path = "Compilations/Need for Speed Most Wanted/17 You'll Be Under My Wheels" +
+                    ".mp3",
+                isVideo = false, playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T20:09:02.000Z"), albumId = "568",
+                artistId = "505", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass artist param`() {
+        val artist = "some-artist"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search_ok.json",
+            expectedParam = "artist=$artist"
+        ) {
+            client.api.search(artist = artist).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass album param`() {
+        val album = "some-album"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search_ok.json",
+            expectedParam = "album=$album"
+        ) {
+            client.api.search(album = album).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass title param`() {
+        val title = "some-title"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search_ok.json",
+            expectedParam = "title=$title"
+        ) {
+            client.api.search(title = title).execute()
+        }
+    }
+
+    @Test
+    fun `Should contain any param`() {
+        val any = "AnyString"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search_ok.json",
+            expectedParam = "any=$any"
+        ) {
+            client.api.search(any = any).execute()
+        }
+    }
+
+    @Test
+    fun `Should contain count param`() {
+        val count = 11
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search_ok.json",
+            expectedParam = "count=$count"
+        ) {
+            client.api.search(count = count).execute()
+        }
+    }
+
+    @Test
+    fun `Should contain offset param`() {
+        val offset = 54
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search_ok.json",
+            expectedParam = "offset=$offset"
+        ) {
+            client.api.search(offset = offset).execute()
+        }
+    }
+
+    @Test
+    fun `Should contain newerThan param`() {
+        val newerThan = Calendar.getInstance()
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search_ok.json",
+            expectedParam = "newerThan=${newerThan.time.time}"
+        ) {
+            client.api.search(newerThan = newerThan.time.time).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiSearchThreeTest.kt

@@ -0,0 +1,146 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Album
+import org.moire.ultrasonic.api.subsonic.models.Artist
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+import org.moire.ultrasonic.api.subsonic.models.SearchThreeResult
+
+/**
+ * Integration test for [SubsonicAPIClient] for search3 call.
+ */
+class SubsonicApiSearchThreeTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.search3("some-query").execute()
+        }
+
+        response.searchResult `should not be` null
+        response.searchResult `should be equal to` SearchThreeResult()
+    }
+
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("search3_ok.json")
+
+        val response = client.api.search3("some-query").execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.searchResult) {
+            artistList.size `should be equal to` 1
+            artistList[0] `should be equal to` Artist(
+                id = "505", name = "The Prodigy",
+                coverArt = "ar-505", albumCount = 5
+            )
+            albumList.size `should be equal to` 1
+            albumList[0] `should be equal to` Album(
+                id = "855",
+                name = "Always Outnumbered, Never Outgunned",
+                artist = "The Prodigy", artistId = "505", coverArt = "al-855", songCount = 12,
+                duration = 3313, created = parseDate("2016-10-23T20:57:27.000Z"),
+                year = 2004, genre = "Electronic"
+            )
+            songList.size `should be equal to` 1
+            songList[0] `should be equal to` MusicDirectoryChild(
+                id = "5831", parent = "5766",
+                isDir = false,
+                title = "You'll Be Under My Wheels", album = "Need for Speed Most Wanted",
+                artist = "The Prodigy", track = 17, year = 2005, genre = "Rap",
+                coverArt = "5766", size = 5607024, contentType = "audio/mpeg",
+                suffix = "mp3", duration = 233, bitRate = 192,
+                path = "Compilations/Need for Speed Most Wanted/17 You'll Be Under My Wheels" +
+                    ".mp3",
+                isVideo = false, playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T20:09:02.000Z"), albumId = "568",
+                artistId = "505", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass query as request param`() {
+        val query = "some-wip-query"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search3_ok.json",
+            expectedParam = "query=$query"
+        ) {
+            client.api.search3(query = query).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass artist count as request param`() {
+        val artistCount = 67
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search3_ok.json",
+            expectedParam = "artistCount=$artistCount"
+        ) {
+            client.api.search3("some", artistCount = artistCount).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass artist offset as request param`() {
+        val artistOffset = 34
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search3_ok.json",
+            expectedParam = "artistOffset=$artistOffset"
+        ) {
+            client.api.search3("some", artistOffset = artistOffset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass album count as request param`() {
+        val albumCount = 21
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search3_ok.json",
+            expectedParam = "albumCount=$albumCount"
+        ) {
+            client.api.search3("some", albumCount = albumCount).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass album offset as request param`() {
+        val albumOffset = 43
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search3_ok.json",
+            expectedParam = "albumOffset=$albumOffset"
+        ) {
+            client.api.search3("some", albumOffset = albumOffset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass song count as request param`() {
+        val songCount = 15
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search3_ok.json",
+            expectedParam = "songCount=$songCount"
+        ) {
+            client.api.search3("some", songCount = songCount).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id as request param`() {
+        val musicFolderId = "43"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search3_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.search3("some", musicFolderId = musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiSearchTwoTest.kt

@@ -0,0 +1,142 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.models.Album
+import org.moire.ultrasonic.api.subsonic.models.Artist
+import org.moire.ultrasonic.api.subsonic.models.MusicDirectoryChild
+import org.moire.ultrasonic.api.subsonic.models.SearchTwoResult
+
+/**
+ * Integration test for [SubsonicAPIClient] for search2 call.
+ */
+class SubsonicApiSearchTwoTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        val response = checkErrorCallParsed(mockWebServerRule) {
+            client.api.search2("some-query").execute()
+        }
+
+        response.searchResult `should not be` null
+        response.searchResult `should be equal to` SearchTwoResult()
+    }
+
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("search2_ok.json")
+
+        val response = client.api.search2("some-query").execute()
+
+        assertResponseSuccessful(response)
+        with(response.body()!!.searchResult) {
+            artistList.size `should be equal to` 1
+            artistList[0] `should be equal to` Artist(id = "522", name = "The Prodigy")
+            albumList.size `should be equal to` 1
+            albumList[0] `should be equal to` Album(
+                id = "8867", parent = "522", title = "Always Outnumbered, Never Outgunned",
+                album = "Always Outnumbered, Never Outgunned", artist = "The Prodigy",
+                year = 2004, genre = "Electronic", coverArt = "8867", playCount = 0,
+                created = parseDate("2016-10-23T20:57:27.000Z")
+            )
+            songList.size `should be equal to` 1
+            songList[0] `should be equal to` MusicDirectoryChild(
+                id = "5831", parent = "5766",
+                isDir = false,
+                title = "You'll Be Under My Wheels", album = "Need for Speed Most Wanted",
+                artist = "The Prodigy", track = 17, year = 2005, genre = "Rap",
+                coverArt = "5766", size = 5607024, contentType = "audio/mpeg",
+                suffix = "mp3", duration = 233, bitRate = 192,
+                path = "Compilations/Need for Speed Most Wanted/17 You'll Be Under My Wheels" +
+                    ".mp3",
+                isVideo = false, playCount = 0, discNumber = 1,
+                created = parseDate("2016-10-23T20:09:02.000Z"),
+                albumId = "568", artistId = "505", type = "music"
+            )
+        }
+    }
+
+    @Test
+    fun `Should pass query id in request param`() {
+        val query = "some"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search2_ok.json",
+            expectedParam = "query=$query"
+        ) {
+            client.api.search2(query).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass artist count in request param`() {
+        val artistCount = 45
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search2_ok.json",
+            expectedParam = "artistCount=$artistCount"
+        ) {
+            client.api.search2("some", artistCount = artistCount).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass artist offset in request param`() {
+        val artistOffset = 13
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search2_ok.json",
+            expectedParam = "artistOffset=$artistOffset"
+        ) {
+            client.api.search2("some", artistOffset = artistOffset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass album count in request param`() {
+        val albumCount = 30
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search2_ok.json",
+            expectedParam = "albumCount=$albumCount"
+        ) {
+            client.api.search2("some", albumCount = albumCount).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass album offset in request param`() {
+        val albumOffset = 91
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search2_ok.json",
+            expectedParam = "albumOffset=$albumOffset"
+        ) {
+            client.api.search2("some", albumOffset = albumOffset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass song count in request param`() {
+        val songCount = 22
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search2_ok.json",
+            expectedParam = "songCount=$songCount"
+        ) {
+            client.api.search2("some", songCount = songCount).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass music folder id in request param`() {
+        val musicFolderId = "565"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "search2_ok.json",
+            expectedParam = "musicFolderId=$musicFolderId"
+        ) {
+            client.api.search2("some", musicFolderId = musicFolderId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiSetRatingTest.kt

@@ -0,0 +1,59 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.response.SubsonicResponse
+
+/**
+ * Integration test for [SubsonicAPIClient] for setRating request.
+ */
+class SubsonicApiSetRatingTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse setRating ok response`() {
+        val id = "110"
+        val rating = 3
+
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.setRating(id, rating).execute()
+
+        assertResponseSuccessful(response)
+        response.body()?.status `should be` SubsonicResponse.Status.OK
+    }
+
+    @Test
+    fun `Should parse setRating error response`() {
+        val id = "110223"
+        val rating = 5
+
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.setRating(id, rating).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass id parameter`() {
+        val id = "110"
+        val rating = 5
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.setRating(id, rating).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass rating parameter`() {
+        val id = "110"
+        val rating = 5
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "rating=$rating"
+        ) {
+            client.api.setRating(id, rating).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiStarTest.kt

@@ -0,0 +1,63 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.response.SubsonicResponse
+
+/**
+ * Integration test for [SubsonicAPIClient] for star request.
+ */
+class SubsonicApiStarTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse star ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.star().execute()
+
+        assertResponseSuccessful(response)
+        response.body()?.status `should be` SubsonicResponse.Status.OK
+    }
+
+    @Test
+    fun `Should parse star error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.star().execute()
+        }
+    }
+
+    @Test
+    fun `Should pass id param`() {
+        val id = "110"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.star(id = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass artist id param`() {
+        val artistId = "123"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "artistId=$artistId"
+        ) {
+            client.api.star(artistId = artistId).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass album id param`() {
+        val albumId = "1001"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "albumId=$albumId"
+        ) {
+            client.api.star(albumId = albumId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiStreamTest.kt

@@ -0,0 +1,138 @@
+package org.moire.ultrasonic.api.subsonic
+
+import okhttp3.mockwebserver.MockResponse
+import org.amshove.kluent.`should be`
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should not be`
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] for [SubsonicAPIDefinition.stream] call.
+ */
+class SubsonicApiStreamTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle api error response`() {
+        mockWebServerRule.enqueueResponse("request_data_not_found_error_response.json")
+
+        val response = client.api.stream("some-id").execute().toStreamResponse()
+
+        with(response) {
+            stream `should be` null
+            responseHttpCode `should be equal to` 200
+            apiError `should be equal to` SubsonicError.RequestedDataWasNotFound
+        }
+    }
+
+    @Test
+    fun `Should handle server error`() {
+        val httpErrorCode = 404
+        mockWebServerRule.mockWebServer.enqueue(MockResponse().setResponseCode(httpErrorCode))
+
+        val response = client.api.stream("some-id").execute().toStreamResponse()
+
+        with(response) {
+            stream `should be` null
+            responseHttpCode `should be equal to` httpErrorCode
+            apiError `should be` null
+        }
+    }
+
+    @Test
+    fun `Should return successful call stream`() {
+        mockWebServerRule.mockWebServer.enqueue(
+            MockResponse()
+                .setBody(mockWebServerRule.loadJsonResponse("ping_ok.json"))
+        )
+
+        val response = client.api.stream("some-id").execute().toStreamResponse()
+
+        with(response) {
+            responseHttpCode `should be equal to` 200
+            apiError `should be` null
+            stream `should not be` null
+            val expectedContent = mockWebServerRule.loadJsonResponse("ping_ok.json")
+            stream!!.bufferedReader().readText() `should be equal to` expectedContent
+        }
+    }
+
+    @Test
+    fun `Should pass id as parameter`() {
+        val id = "asdo123"
+
+        mockWebServerRule.assertRequestParam("ping_ok.json", id) {
+            client.api.stream(id = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass max bit rate as param`() {
+        val maxBitRate = 360
+
+        mockWebServerRule.assertRequestParam(
+            "ping_ok.json",
+            "maxBitRate=$maxBitRate"
+        ) {
+            client.api.stream("some-id", maxBitRate = maxBitRate).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass format as param`() {
+        val format = "aac"
+
+        mockWebServerRule.assertRequestParam(
+            "ping_ok.json",
+            "format=$format"
+        ) {
+            client.api.stream("some-id", format = format).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass time offset as param`() {
+        val timeOffset = 155
+
+        mockWebServerRule.assertRequestParam(
+            "ping_ok.json",
+            "timeOffset=$timeOffset"
+        ) {
+            client.api.stream("some-id", timeOffset = timeOffset).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass video size as param`() {
+        val videoSize = "44144"
+
+        mockWebServerRule.assertRequestParam(
+            "ping_ok.json",
+            "size=$videoSize"
+        ) {
+            client.api.stream("some-id", videoSize = videoSize).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass estimate content length as param`() {
+        val estimateContentLength = true
+
+        mockWebServerRule.assertRequestParam(
+            "ping_ok.json",
+            "estimateContentLength=$estimateContentLength"
+        ) {
+            client.api.stream("some-id", estimateContentLength = estimateContentLength).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass converted as param`() {
+        val converted = false
+
+        mockWebServerRule.assertRequestParam(
+            "ping_ok.json",
+            "converted=$converted"
+        ) {
+            client.api.stream("some-id", converted = converted).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiUnstarTest.kt

@@ -0,0 +1,66 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.response.SubsonicResponse
+
+/**
+ * Integration test for [SubsonicAPIClient] for unstar call.
+ */
+class SubsonicApiUnstarTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should parse ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.unstar().execute()
+
+        assertResponseSuccessful(response)
+        response.body()?.status `should be` SubsonicResponse.Status.OK
+    }
+
+    @Test
+    fun `Should parse error response`() {
+        checkErrorCallParsed(
+            mockWebServerRule,
+            {
+                client.api.unstar().execute()
+            }
+        )
+    }
+
+    @Test
+    fun `Should pass id param`() {
+        val id = "545"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "id=$id"
+        ) {
+            client.api.unstar(id = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass artistId param`() {
+        val artistId = "644"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "artistId=$artistId"
+        ) {
+            client.api.unstar(artistId = artistId).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass albumId param`() {
+        val albumId = "3344"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "albumId=$albumId"
+        ) {
+            client.api.unstar(albumId = albumId).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiUpdatePlaylistTest.kt

@@ -0,0 +1,97 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIClient] for updatePlaylist call.
+ */
+class SubsonicApiUpdatePlaylistTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.updatePlaylist("10").execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.updatePlaylist("15").execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass playlist id param in request`() {
+        val id = "5453"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "playlistId=$id"
+        ) {
+            client.api.updatePlaylist(id = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass name param in request`() {
+        val name = "some-name"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "name=$name"
+        ) {
+            client.api.updatePlaylist("22", name = name).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass comment param in request`() {
+        val comment = "some-unusual-comment"
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "comment=$comment"
+        ) {
+            client.api.updatePlaylist("42", comment = comment).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass public param in request`() {
+        val public = true
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "public=$public"
+        ) {
+            client.api.updatePlaylist("53", public = public).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass song ids to update in request`() {
+        val songIds = listOf("45", "81")
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "songIdToAdd=${songIds[0]}&songIdToAdd=${songIds[1]}"
+        ) {
+            client.api.updatePlaylist("25", songIdsToAdd = songIds).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass song indexes to remove in request`() {
+        val songIndexesToRemove = listOf(129, 1)
+
+        mockWebServerRule.assertRequestParam(
+            responseResourceName = "ping_ok.json",
+            expectedParam = "songIndexToRemove=${songIndexesToRemove[0]}&" +
+                "songIndexToRemove=${songIndexesToRemove[1]}"
+        ) {
+            client.api.updatePlaylist("49", songIndexesToRemove = songIndexesToRemove).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/SubsonicApiUpdateShareTest.kt

@@ -0,0 +1,51 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.junit.Test
+
+/**
+ * Integration test for [SubsonicAPIDefinition.updateShare] call.
+ */
+class SubsonicApiUpdateShareTest : SubsonicAPIClientTest() {
+    @Test
+    fun `Should handle error response`() {
+        checkErrorCallParsed(mockWebServerRule) {
+            client.api.updateShare("11").execute()
+        }
+    }
+
+    @Test
+    fun `Should handle ok response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        val response = client.api.updateShare("12").execute()
+
+        assertResponseSuccessful(response)
+    }
+
+    @Test
+    fun `Should pass id in request params`() {
+        val id = "4432"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "id=$id") {
+            client.api.updateShare(id = id).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass description in request params`() {
+        val description = "some-description"
+
+        mockWebServerRule.assertRequestParam(expectedParam = "description=$description") {
+            client.api.updateShare("123", description = description).execute()
+        }
+    }
+
+    @Test
+    fun `Should pass expires in request params`() {
+        val expires = 223123123L
+
+        mockWebServerRule.assertRequestParam(expectedParam = "expires=$expires") {
+            client.api.updateShare("12", expires = expires).execute()
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/VersionAwareJacksonConverterFactoryTest.kt

@@ -0,0 +1,52 @@
+package org.moire.ultrasonic.api.subsonic
+
+import org.amshove.kluent.`should be`
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Integration test for [VersionAwareJacksonConverterFactory].
+ */
+class VersionAwareJacksonConverterFactoryTest : SubsonicAPIClientTest() {
+    private val initialProtocolVersion = SubsonicAPIVersions.V1_1_0
+    private var updatedProtocolVersion = SubsonicAPIVersions.V1_1_0
+
+    @Before
+    override fun setUp() {
+        config = SubsonicClientConfiguration(
+            mockWebServerRule.mockWebServer.url("/").toString(),
+            USERNAME,
+            PASSWORD,
+            initialProtocolVersion,
+            CLIENT_ID
+        )
+        client = SubsonicAPIClient(config)
+    }
+
+    @Test
+    fun `Should update version from response`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+
+        client.api.ping().execute()
+
+        client.protocolVersion.`should be`(SubsonicAPIVersions.V1_13_0)
+    }
+
+    @Test
+    fun `Should update version from response with utf-8 bom`() {
+        mockWebServerRule.enqueueResponse("ping_ok_utf8_bom.json")
+
+        client.api.ping().execute()
+
+        client.protocolVersion.`should be`(SubsonicAPIVersions.V1_16_0)
+    }
+
+    @Test
+    fun `Should not update version if response json doesn't contain version`() {
+        mockWebServerRule.enqueueResponse("non_subsonic_response.json")
+
+        client.api.stream("1234").execute()
+
+        client.protocolVersion.`should be`(initialProtocolVersion)
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/interceptors/BaseInterceptorTest.kt

@@ -0,0 +1,35 @@
+package org.moire.ultrasonic.api.subsonic.interceptors
+
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import org.junit.Before
+import org.junit.Rule
+import org.moire.ultrasonic.api.subsonic.rules.MockWebServerRule
+
+/**
+ * Base class for testing [okhttp3.Interceptor] implementations.
+ */
+abstract class BaseInterceptorTest {
+    @Rule @JvmField val mockWebServerRule = MockWebServerRule()
+
+    lateinit var client: OkHttpClient
+
+    abstract val interceptor: Interceptor
+
+    @Before
+    fun setUp() {
+        client = OkHttpClient.Builder().addInterceptor(interceptor).build()
+    }
+
+    /**
+     * Creates [Request] to use with [mockWebServerRule].
+     *
+     * @param additionalParams passes [Request.Builder] to add additionally required
+     * params to the [Request].
+     */
+    fun createRequest(additionalParams: (Request.Builder) -> Unit): Request = Request.Builder()
+        .url(mockWebServerRule.mockWebServer.url("/"))
+        .also { additionalParams(it) }
+        .build()
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/interceptors/PasswordHexInterceptorTest.kt

@@ -0,0 +1,33 @@
+package org.moire.ultrasonic.api.subsonic.interceptors
+
+import okhttp3.Interceptor
+import okhttp3.mockwebserver.MockResponse
+import org.amshove.kluent.`should contain`
+import org.amshove.kluent.`should not contain`
+import org.apache.commons.codec.binary.Hex
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.PASSWORD
+
+/**
+ * Integration test for [PasswordHexInterceptor].
+ */
+class PasswordHexInterceptorTest : BaseInterceptorTest() {
+    private val password = "some-password"
+
+    override val interceptor: Interceptor get() = PasswordHexInterceptor(password)
+
+    @Test
+    fun `Should pass hex encoded password in query params`() {
+        mockWebServerRule.mockWebServer.enqueue(MockResponse())
+        val request = createRequest { }
+
+        client.newCall(request).execute()
+
+        with(mockWebServerRule.mockWebServer.takeRequest()) {
+            requestLine `should not contain` "s="
+            requestLine `should not contain` "t="
+            val encodedPassword = String(Hex.encodeHex(PASSWORD.toByteArray(), false))
+            requestLine `should contain` "p=enc:$encodedPassword"
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/interceptors/PasswordMD5InterceptorTest.kt

@@ -0,0 +1,42 @@
+package org.moire.ultrasonic.api.subsonic.interceptors
+
+import java.security.MessageDigest
+import okhttp3.Interceptor
+import okhttp3.mockwebserver.MockResponse
+import org.amshove.kluent.`should contain`
+import org.amshove.kluent.`should not contain`
+import org.apache.commons.codec.binary.Hex
+import org.junit.Test
+
+/**
+ * Integration test for [PasswordMD5Interceptor].
+ */
+class PasswordMD5InterceptorTest : BaseInterceptorTest() {
+    private val password = "some-password"
+    override val interceptor: Interceptor get() = PasswordMD5Interceptor(password)
+
+    @Test
+    fun `Should pass password hash and salt in query params`() {
+        mockWebServerRule.mockWebServer.enqueue(MockResponse())
+        val request = createRequest { }
+
+        client.newCall(request).execute()
+
+        with(mockWebServerRule.mockWebServer.takeRequest()) {
+            requestLine `should contain` "s="
+            requestLine `should contain` "t="
+            requestLine `should not contain` "p=enc:"
+
+            val salt = requestLine.split('&').find { it.startsWith("s=") }
+                ?.substringAfter('=')?.substringBefore(" ")
+            val expectedToken = String(
+                Hex.encodeHex(
+                    MessageDigest.getInstance("MD5")
+                        .digest("$password$salt".toByteArray()),
+                    true
+                )
+            )
+            requestLine `should contain` "t=$expectedToken"
+        }
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/interceptors/RangeHeaderInterceptorTest.kt

@@ -0,0 +1,59 @@
+package org.moire.ultrasonic.api.subsonic.interceptors
+
+import okhttp3.Interceptor
+import okhttp3.mockwebserver.MockResponse
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should contain`
+import org.amshove.kluent.`should not contain`
+import org.junit.Test
+
+/**
+ * Unit test for [RangeHeaderInterceptor].
+ */
+class RangeHeaderInterceptorTest : BaseInterceptorTest() {
+
+    override val interceptor: Interceptor
+        get() = RangeHeaderInterceptor()
+
+    @Test
+    fun `Should update uppercase range header`() {
+        mockWebServerRule.mockWebServer.enqueue(MockResponse())
+        val offset = 111
+        val request = createRequest {
+            it.addHeader("Range", "$offset")
+        }
+
+        client.newCall(request).execute()
+
+        val executedRequest = mockWebServerRule.mockWebServer.takeRequest()
+        executedRequest.headers.names() `should contain` "Range"
+        executedRequest.headers["Range"]!! `should be equal to` "bytes=$offset-"
+    }
+
+    @Test
+    fun `Should not add range header if request doesnt contain it`() {
+        mockWebServerRule.mockWebServer.enqueue(MockResponse())
+        val request = createRequest { }
+
+        client.newCall(request).execute()
+
+        val executedRequest = mockWebServerRule.mockWebServer.takeRequest()
+        executedRequest.headers.names() `should not contain` "Range"
+        executedRequest.headers.names() `should not contain` "range"
+    }
+
+    @Test
+    fun `Should update lowercase range header`() {
+        mockWebServerRule.mockWebServer.enqueue(MockResponse())
+        val offset = 51233
+        val request = createRequest {
+            it.addHeader("range", "$offset")
+        }
+
+        client.newCall(request).execute()
+
+        val executedRequest = mockWebServerRule.mockWebServer.takeRequest()
+        executedRequest.headers.names() `should contain` "Range"
+        executedRequest.headers["Range"]!! `should be equal to` "bytes=$offset-"
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/interceptors/VersionInterceptorTest.kt

@@ -0,0 +1,31 @@
+package org.moire.ultrasonic.api.subsonic.interceptors
+
+import kotlin.LazyThreadSafetyMode.NONE
+import okhttp3.Interceptor
+import org.amshove.kluent.`should contain`
+import org.junit.Test
+import org.moire.ultrasonic.api.subsonic.SubsonicAPIVersions
+import org.moire.ultrasonic.api.subsonic.enqueueResponse
+
+/**
+ * Integration test for [VersionInterceptor].
+ */
+class VersionInterceptorTest : BaseInterceptorTest() {
+    private val initialProtocolVersion = SubsonicAPIVersions.V1_1_0
+
+    override val interceptor: Interceptor by lazy(NONE) {
+        VersionInterceptor(initialProtocolVersion)
+    }
+
+    @Test
+    fun `Should add initial protocol version to request`() {
+        mockWebServerRule.enqueueResponse("ping_ok.json")
+        val request = createRequest {}
+
+        client.newCall(request).execute()
+
+        val requestLine = mockWebServerRule.mockWebServer.takeRequest().requestLine
+
+        requestLine `should contain` "v=${initialProtocolVersion.restApiVersion}"
+    }
+}

core/subsonic-api/src/integrationTest/kotlin/org/moire/ultrasonic/api/subsonic/rules/MockWebServerRule.kt

@@ -0,0 +1,26 @@
+package org.moire.ultrasonic.api.subsonic.rules
+
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.rules.TestRule
+import org.junit.runner.Description
+import org.junit.runners.model.Statement
+
+/**
+ * Starts mock web server for test and shut it down after.
+ */
+class MockWebServerRule : TestRule {
+    val mockWebServer = MockWebServer()
+
+    override fun apply(base: Statement?, description: Description?): Statement {
+        return object : Statement() {
+            override fun evaluate() {
+                try {
+                    mockWebServer.start()
+                    base?.evaluate()
+                } finally {
+                    mockWebServer.shutdown()
+                }
+            }
+        }
+    }
+}

core/subsonic-api/src/integrationTest/resources/error_first_generic_error.json

@@ -0,0 +1,10 @@
+{
+  "subsonic-response": {
+    "error": {
+      "message": "Video streaming not supported",
+      "code": 0
+    },
+    "version": "1.8.0",
+    "status": "failed"
+  }
+}

core/subsonic-api/src/integrationTest/resources/generic_error.json

@@ -0,0 +1,10 @@
+{
+  "subsonic-response": {
+    "status": "failed",
+    "version": "1.15.0",
+    "error": {
+      "code": 0,
+      "message": "Some generic error message."
+    }
+  }
+}

core/subsonic-api/src/integrationTest/resources/get_album_list_2_ok.json

@@ -0,0 +1,31 @@
+{
+  "subsonic-response" : {
+    "status" : "ok",
+    "version" : "1.15.0",
+    "albumList2" : {
+      "album" : [ {
+        "id" : "962",
+        "name" : "Fury",
+        "artist" : "Sick Puppies",
+        "artistId" : "473",
+        "coverArt" : "al-962",
+        "songCount" : 13,
+        "duration" : 2591,
+        "created" : "2017-09-02T17:34:51.000Z",
+        "year" : 2016,
+        "genre" : "Alternative Rock"
+      }, {
+        "id" : "961",
+        "name" : "Endless Forms Most Beautiful",
+        "artist" : "Nightwish",
+        "artistId" : "559",
+        "coverArt" : "al-961",
+        "songCount" : 22,
+        "duration" : 9469,
+        "created" : "2017-09-02T16:22:47.000Z",
+        "year" : 2015,
+        "genre" : "Symphonic Metal"
+      } ]
+    }
+  }
+}