Merge branch 'developer'

Author: abainczyk

.gitignore

@@ -7,15 +7,18 @@ main/logs
 target
 *.class
 hs_err_pid*
+backend/logs
 
 # JavaScript
-main/src/main/webapp/node_modules
-main/src/main/webapp/dist
-main/src/main/webapp/tests/coverage
-main/src/main/webapp/assets/fonts
-main/src/main/webapp/assets/swagger-ui
+cli/src/main/javascript/node_modules
+frontend/src/main/javascript/node_modules
+frontend/src/main/javascript/dist
+frontend/src/main/javascript/tests/coverage
+frontend/src/main/javascript/assets/fonts
 
 # Auto Generated Swagger Doc
 main/src/main/webapp/restdocs
 
 main/uploads
+
+frontend/src/main/javascript/npm-debug\.log

CHANGELOG.md

@@ -1,3 +1,31 @@
+# ALEX 1.4.0
+
+## Breaking Changes
+
+* Symbol abbreviations have been removed. To use old exported symbol sets, remove the *abbreviation* property manually
+from the JSON file.
+
+* The HTML Element Picker does not work as before. In order to use it properly, make sure you start your browser with
+disabled CORS rules or use a plugin. See the [user documentation](http://learnlib.github.io/alex/book/1.4.0/) for 
+detailed instructions.
+
+## Features
+
+* Define a default web driver to execute tests in
+* Immediately stop learning instead of waiting for the current iteration to finish
+* Support for native headless web driver support for Chrome and Firefox
+* Action recorder - Record a sequence of actions for a symbol in the Element Picker
+* Extended testing capability - Save and execute test cases without starting a learning process
+* Calculate the difference between two models
+* Added Safari driver
+* New actions:
+    * Wait for a text to appear
+    * Wait for the value of an elements attribute
+    * Interact with alert, prompt and confirm dialogs
+    * Validate JSON against a JSON schema
+    
+See the [user documentation](http://learnlib.github.io/alex/book/1.4.0/) for more details.
+
 # ALEX 1.3.0
 
 ## Breaking Changes

README.md

@@ -1,56 +1,23 @@
 <p align="center">
-    <img src="assets/images/logo.png" style="max-width:100%;">
+    <img src="src/main/resources/images/logo.png" style="max-width:100%;">
 </p>
 
 # ALEX
 
-Automata Learning Experience (ALEX) is a web application that allows you run automated tests on web applications and JSON-based REST services using Active Automata Learning.
+Automata Learning Experience (ALEX) is an extension of the [LearnLib](https://github.com/LearnLib/learnlib) that allows 
+you run automated tests on web applications and JSON-based REST APIs using active automata learning.
 
-## How it works
+Users model basic test inputs for their target application which are used by ALEX to automatically infer an automaton 
+model, or to be more precise, a [Mealy machine](https://en.wikipedia.org/wiki/Mealy_machine) that represents the 
+behavior of the web application.
 
-Let us take a look at the example of an authentication system.
-For an integration test you would probably write tests using Selenium or something else that check the following behavior:
-
-* register > login > logout _should work_
-* logout _should not work_
-* register > logout _should not work_
-* ...
-
-With increasing complexity and feature set of an application, integration tests might be hard to maintain if all possible and impossible combinations of features should be tested.
-With ALEX, we follow a different, more automated approach that
-
-1. does not require any knowledge about the implementation of an application,
-2. does not require any experience in programming and
-3. separates the language specific tests from the application to test.
-
-Assume the authentication system mentioned above has the following features: _register_, _login_ and _logout_.
-Then, we model each feature independent of each other using e.g. [Selenium](http://www.seleniumhq.org/).
-In Active Automata Learning, this set of testable features is called **alphabet** where the elements of the alphabet are called **symbols**.
-A sequence of symbols is called a **word**.
-
-We then pass the learning alphabet to a **learner** that uses specific algorithms to create a model of the underlying application and how it behaves based on the given symbols.
-Therefore, words are executed on the real system under learning and its reactions are observed.
-Finally, the learner creates a **hypothesis** as an output that is modeled as a [Mealy machine](https://en.wikipedia.org/wiki/Mealy_machine).
-In this example, it would hopefully look like this:
-
-![Hypothesis](assets/images/hypothesis.jpg)
-
-As it can be seen, the learner has learned the application and all features work as intended.
-From here on, more symbols can be added and learned.
-
-It can be that the learner has not learned the application correctly, i.e. there is a word in the model that has a different output than the actual application.
-In fact, one can never be a 100% sure if the model actually represents the system under learning.
-How to check for and handle these mistakes is described in the [user manual](http://learnlib.github.io/alex/book/1.2.1/contents/user-manual/index.html).
-
-If you want to know more about Active Automata Learning, you can find some resources at [Google Scholar](https://scholar.google.de/scholar?hl=de&q=active+automata+learning) or the homepage of the [LearnLib](http://learnlib.de/).
-
-## Installation and first login
+## Installation and login
 
 We developed and tested ALEX using either Windows 8.1 and higher and Linux Ubuntu 14.10 and higher.
 As the application runs on JAVA, any other system with an installed JVM should do fine.
-We also advise to use a modern web browser like Google Chrome >= v46, Mozilla Firefox >= v42 or Microsoft Edge with JavaScript enabled in order to run the front-end properly.
+We also advise to use a modern web browser like Google Chrome, Mozilla Firefox or Microsoft Edge with JavaScript enabled.
 
-After the first start, you can login as admin backend using the account below.
+After the first start, you can login as an admin using the account below.
 
 Email: *admin@alex.example* <br>
 Password: *admin*
@@ -60,57 +27,39 @@ Password: *admin*
 Make sure you have Java 8 installed on your system.
 
 1. Download the latest version. [Download](https://github.com/LearnLib/alex/releases/latest)
-2. Open a terminal and start the war archive using `java -jar ALEX.war [--port=XXXX]`
+2. Open a terminal and start the *war* archive using `java -jar ALEX.war [--port=XXXX]`
 3. Open *http://localhost:8000* in a web browser
 
 #### From source
 
-For the Installation from the source files make sure your system matches the following system requirements:
+For the installation from the source files make sure your system matches the following requirements:
 
 * Java JDK 8
 * Maven 3
 * Node.js v7.9.* and the NPM
 
-To install and run ALEX, execute the following commands in a directory of your choice:
+To obtain ALEX execute the following commands in a directory of your choice:
 
 1. `git clone https://github.com/LearnLib/alex.git`
 2. `cd alex`
-3. `mvn install [-DskipTests]`
-4. `cd main`
-5. `mvn spring-boot:run [-Dport=XXXX]`
-6. open *http://localhost:8000* in a web browser
+
+Afterwards you can build and run ALEX by running following commands:
+
+1. `mvn clean package [-DskipTests]`
+2. `java -jar build/target/ALEX/*war [--alex.port=XXXX]`
+3. open *http://localhost:8000* in a web browser
+
+Or, if you just want to start the backend, you can use:
+
+1. `cd main`
+2. `mvn spring-boot:run [-Dalex.port=XXXX]`
+3. open *http://localhost:8000* in a web browser
+
 
 ## Further reading
 
-* [User manual](http://learnlib.github.io/alex/book/1.2.1/contents/user-manual/index.html)
-* [Examples to get started](http://learnlib.github.io/alex/book/1.2.1/contents/examples/index.html)
-* [Developer docs](http://learnlib.github.io/alex/book/1.2.1/contents/developer-documents/index.html)
-
-## FAQs
-
-**Is ALEX ready for production use?** <br>
-ALEX has already been used by a class at the TU Dortmund University as a tool to test a student project for the last two years.
-As far as we are concerned, we used the application to learn applications like [Bugzilla](https://www.bugzilla.org/), 
-parts of the famous [Wordpress](https://wordpress.org/) and the majority of the [TodoMVC](http://todomvc.com/) project.
-
-**Could I potentially learn any available application that is accessible over the internet?** <br>
-Yes, you could, but really should not do that, since testing usually takes a lot of traffic, and your test targets may not like it.
-But we do not programmatically prohibit it either.
-The primary use case is to use ALEX for testing applications that are installed locally or in the same network.
-
-**Do I really not have to have any programming experience?** <br>
-Yes and no, it depends on how you define programming experience.
-We made the best efforts to abstract all necessary steps to test a web application with ease.
-While modeling Selenium tests, it may eventually be helpful to have basic understanding of HTML and CSS.
-The same goes for modeling REST tests where it is needed that you can write JSON documents.
-But to our understanding neither JSON, HTML nor CSS are programming languages.
-
-**How potent does my system have to be to run tests?** <br>
-Learning is a CPU and memory intense process, but we cannot really tell you an lower bound for your system specs.
-From our own observations, it is advised to have at least 2Gb of RAM and a relatively modern Dual Core CPU to run tests at a satisfiable performance.
-The more power your system has, the faster your tests should execute.
-But feel free to test it on your Raspberry PI.
-
-**I want to learn a specific feature of my application but ALEX does not provide a way to model it. What can I do?** <br>
-Initially, we did not develop ALEX as a solution to all situations that may occur in a web application, but to the most common ones.
-If you think a key feature is missing, feel free to submit an issue and we will see what we can do.
+* [User manual](http://learnlib.github.io/alex/book/1.4.0/contents/user-manual/index.html)
+* [Examples](http://learnlib.github.io/alex/book/1.4.0/contents/examples/index.html)
+* [Developer docs](http://learnlib.github.io/alex/book/1.4.0/contents/developer-documents/index.html)
+* [Active automata learning](https://scholar.google.de/scholar?hl=de&q=active+automata+learning)
+* [LearnLib](http://learnlib.de/)