/*
    тут - объединим несколько заданий в одно
    нет смысла в твоем случае делать их последовательно
*/

Reporting

как встроить алюр-репорт -
https://drive.google.com/file/d/0B8hgIBw8-V-AVnVCNlpUd1hZaXM/view?usp=sharing

в faq - есть раздер по репортингу
https://docs.google.com/document/d/13dNyFGbI7mV22UUhH8E0LJ7SzabAmX7Bw7VCHScYfiU/edit?usp=sharing

первая цель - встроить в проект - формирование алюр-репорта
причем - такого, в котором форминуются скриншоты для каждого тест-метода
это - сделай и продолжай двигаться дальше

это - делать не надо
но - полюбопытствовать можешь )
https://www.youtube.com/watch?v=w_rPX9TwDkA
http://spirogov.github.io/video-recorder-intieghratsiia-s-jenkins-i-allure-rieportami/
************************************************

OOP: Intro
https://docs.google.com/document/d/1QudwvJewDg9qwg59Yso5aQ4w3CdcPqlsa8Az11B8Y5M/edit
Reusing Tests Setup
https://drive.google.com/file/d/0B8hgIBw8-V-AMVNGRVh1ZTlyaG8/view?usp=sharing

cмотри эти видео
возможно, какие-то мелочи и/или тонкости подметишь для себя
в целом - думаю - ничего нового для тебя не будет

вторая цель - реализовать 2 предка для тест-класса
    в первом - наиболее универсальном - возимся со скриншотами
    в следующем - возимся с открытием урла и очисткой данных после теста
это - сделай и продолжай двигаться дальше

сразу читани вот это
https://docs.google.com/document/d/13dNyFGbI7mV22UUhH8E0LJ7SzabAmX7Bw7VCHScYfiU/edit#heading=h.tz2xue7whvu
весь раздел
там есть интересные нюансы
полезно их понимать
************************************************
Full Coverage with Feature Tests
https://drive.google.com/file/d/0B8hgIBw8-V-AVExIeW1iQ0pXUTg/view
https://drive.google.com/file/d/0B8hgIBw8-V-AUDdxNnpVdXYwbXM/view?usp=sharing

в faq - тоже глянь - есть немного полезного на тему работы с локалсториджем

третья цель - реализовать full coverage

текст задания (та часть, которая касается тебя)
    provide full coverage according your test plan by switching more to feature style tests.
    Move some "coverage" from E2E to FT in order to make E2E smaller,
    more readable and easier to support.
    Leave E2E only for "general" filtering and some basic operations in tasks Life Cycle.

    Make tests fast via implementing correspondent precondition helpers.

в принципе - оптимизировать покрытие по заданию - не обязательно
но в общем - стоит - чтоб понимать - как это делается
    потому - оптимизируй и приводи тест-план - с показанным покрытием
****************
в чем оптимизация
    - что покрыто в е2е - не покрываем фиче-тестами
    - низкоприоритетное - покрываем единожды, на каком-то из контекстов (пример - delete by emptying text)
    - низкоприоритетные варианты фичи, у которой есть покрытые варианты - не покрываем (пример - reopen all & add)
****************
как реализовывать набор гивен-методов - изложено в видео
это так сказать минимально нужное)

а можно и потренироваться в использовании Builder pattern)

чтоб получить что-то типа такого
    given().activeTasks("a").completedTasks("b").atCompletedFilter().prepare();
    вместо
    given(new Task(ACTIVE, "a"), new Task(COMPLETED, "b"))
а таком варианте - не настаиваю
будет вариант given(new Task(ACTIVE, "a"), new Task(COMPLETED, "b")) - тоже ок будет
это лишь в рамках тренировки Builder pattern полезно

дальше - про Builder pattern подробнее
*********************************************************************
ИТОГО - наш финиш
    реализация full coverage
    тест-план для full coverage
    примененный репортинг (приведи парочку скриншотов алюр-репорта - чтоб был виден и приаттаченый скриншот)
    примененные принципы - предки тест-класса
***********************************************************************************

Builder pattern

  https://jlordiales.me/2012/12/13/the-builder-pattern-in-practice/
   http://www.journaldev.com/1425/builder-design-pattern-in-java

   По этим линкам - по моему мнению - неплохо и несложно разъяснено про паттерн Builder
   по второй линке - вообще пошагово

   еще и это пригодится
    вот неплохие линки - про использование this
           https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html
           http://stackoverflow.com/questions/2411270/when-should-i-use-this-in-a-class

   буду иносказательной и я)

   У нас будет класс = то, что мы строим
   и его внутренний класс (а если точнее - nested static class) = builder = как мы это строим

   мы хотим строить пошагово - сначала рассказать в сколь угодно много шагов(любая их комбинация)
   а потом - по собранной в шагах информации - построим наш объект

   и поскольку - чтобы строить объект - мы применяем класс-строитель
   то - конструктор для нашего объекта - не нужно делать public

   Допустим, мы делаем некий напиток
   мы можем добавлять
       воду
       сахар
       красители
       алкоголь
       фрукты
   паковать это в некую тару

   ну и вот это все в комплексе - и есть создание напитка

   вот и создаем класс Drink = т к делаем мы напиток
   и у него внутри - реализуем и класс-строитель = Barman

   public class Drink {
       private int water;
       private int sugar;
       private List<Colour> colours;
       private List<Alcohol> alcohols;
       private List<Fruit> fruits;
       private Bottle bottle;
       /*
           все свойства конечного объекта - описываем как private поля объекта
       */

       private Drink(Barman barman) {
           water = barman.water;
           sugar = barman.sugar ;
           colours = barman.colours;
           alcohols = barman.alcohols;
           fruits = barman.fruits;
           bottle = barman.bottle;
           ...
       }
       /*
           конструктор этого класса = тоже private
           и в качестве параметра он получает как раз объекта-строителя

           в конструкторе - переносим данные из строителя  - в поля нашего объекта
           и далее - (см "..." в коде) при необходимости как-то работаем с данными
       */


       public static class Barman {
           private int water;
           private int sugar;
           private List<Colour> colours;
           private List<Alcohol> alcohols;
           private List<Fruit> fruits;
           private Bottle bottle;
           /*
               у класса-строителя - такой же набор полей
               и они тоже private

               все методы этого класса, кроме одного(build()) -
               как раз и будут собирать эти свойства
           */

           public Barman(Bottle bottle) {
               this.bottle = bottle;
               colours = new ArrayList<Colours> ();
               ...
           }
           /*
               конструктор класса-строителя - объявляем как public
               здесь мы инициализируем все поля этого класса

               если это необходимо - можно реализовать конструктор с параметрами
               цель - передать то, что будет обязательным для заполнения
           */

           public Barman addWater(int water) {
               this.water += water;
               return this;
           }
           /*
               каждый из методов, заполняющих какое-либо из свойств - это public метод
               и возвращает такой метод самого объекта-строителя
           */

           public Barman addFruits(Fruit... fruits) {
               for (Fruit fruit:fruits) {
                   this.fruits.add(fruit);
               }
               return this
           }
           /*
               заметь - такие методы не заново заполняют соответствующие поля - а лишь дополняют то,
               что мы изначально задали в конструкторе

               цель - иметь возможность многократно и в любой последовательности вызывать методы строителя

               для каждого из свойств - реализуем такого плана метод
           */

           public Drink build() {
               return new Drink(this);
           }
           /*
               а этот метод класса-строителя - возвращает новый объект - который мы как раз строим
               и передаем в конструктор - this = наш объект-строитель

               собственно - фактически это и будет создание нашего объекта Drink
               (вспомни - что мы делали в конструкторе класса Drink)
           */
       }
   }

   /*
       если минимально - то это все)

       теперь мы можем создать нашего строителя
       new Drink.Barman(bottle)

       а чтоб эту часть кода сделать нагляднее - можем в классе Drink
       реализовать static метод, возвращающий новый объект типа строитель

       например

   */
   public class Drink {
       ....

       public static Barman composeDrink(Bottle bottle) {
           return new Barman(bottle);
       }

       public static class Barman {
           ...
       }
   }

   /*
        и далее в коде
        применив import static для  composeDrink -
        писать
   */

       composeDrink(bottle)

       а не

       new Drink.Barman(bottle)

   /*
       ну и далее - начинается самое интересное

       composeDrink(bottle) - возвращает объект-строитель
       у которого много методов, "доливающих" наш напиток = уточняющих наш рецепт

       а т к каждый из этих методов - возвращает тот же объект
       мы можем строить любые цепочки вызовов
       и заканчивать такую цепочку - вызовом build

       только в вызове build -  и будет построен объект
       согласно тому - что мы уточнили ранее

   */
      composeDrink(bottle).addWater(...).addAlcohol(...).addFruits(...).addColor(...).addFruits(...).build(); - некий коктейль )
      ...
      composeDrink(bottle).addWater(...).build(); - просто бутылка с водой
      ...
      composeDrink(bottle).build();  - вообще пустая бутылка )


      теперь вспоминаем - о чем это мы

      мы собирались делать вот что
       given().build() - ни одной таски
       given().activeTasks("a","b","c").completedTasks("d", "e").atAllFilter().build() - разные таски на таком-то фильтре
       given()......build() - можно разные делать - в зависимости от потребностей

      Видишь сходство? )

      в общем-то - экономически не оправдано в задаче такого уровня применять этот паттерн
      тут можно прекрасно реализовать несколько гивен-методов
      и этого будет  - с головой достаточно)

      можно просто - в начале реализовать базовый гивен-метод
      и затем - когда он уже будет работать - развить его до такого решения
      чтоб отдельно решать задачу - разобраться с тем что сделать и как сделать