Imagine — you receive a task when you need to test application. Cool, sound simple, but what if it contains a lot of advertisements? What if ads going to loads and shown dynamically on your page?

You automation is going to be an unstable in this conditions. Reasonable question — what can I do this case?

I see few solutions:

1. Setup you test application not to display ads at all. Sounds simple, but there is some cases. For first not all environment support ads disabling. For second — it can be some third-party or even better — an external (test task) environment.
2. Use some proxy, intercept and filter traffic. This case you need to integrate with some proxy, setup test environment, create a rules, apply them in a driver proxy. Sounds quite complex isn’t it?
3. Just create a custom profile, setup it, install some ad-block extension, export and use this profile to driver. Again a lot of steps, but stop… they all simple. No code for ads blocking or traffic filtering. Cool, let’s go this way!

Let’s start our journey. First, let choose some browser — let it be a Firefox.

As I sad, until driver configuration we will no code at all.

Step-by-step:

1. Start a browser as regular user
2. Open a profile manager by typing about:profiles
3. Create a new profile, let’s name it automation — CO
4. Launch profile in new browser to set-up and install all things to fight against ads
5. This step you can configure browser as you want — all setting will be saved in a profile folder
6. And finally install an ad blocker, set-up it, add filters and update them.
7. Save profile by closing opened before browser window
8. Next I copy profile folder (you can find it in about:profiles> Root Directory section of your new profile) to my resource directory. Folder will have name something like — x0fh1by2.automation
9. Final step required code a little bit to make this works

Now let’s make the code work for you.

First we need to create a firefox profile using previously created profile for this we need to load folder as a File:

File profilePath = Paths.get("src", "test", "resources", "x0fh1by2.automation").toFile();

Then create a firefox profile based on loaded profile:

FirefoxProfile profile = new FirefoxProfile(profilePath);

To create a firefox driver with firefox profile we need to create a firefiox options and set profile to:

FirefoxOptions options = new FirefoxOptions();
options.setProfile(profile);

Finally we can create a firefox driver:

WebDriver driver = new FirefoxDriver(options);

And of course test how it works by open any site with some trackers or ads — let it be some local news site:

driver.get("https://local-news-site.net");

For clarity, first I will open it with a standard driver, and then with custom profile.

Let’s compare driver work with Standard vs Custom profiles!

Standard:

Here you can see a lot of ads… Content almost not visible because of it. Also ads take some time, traffic and resources to loads on a page.

Custom:

No ads because we apply [RU] specific filter on profile/extension configuration step. All ads an trackers blocked.

Page loads much… much faster!!1

In my opinion — an amazing result. But here is a dark side — for loading custom profile you need extra time instead of using a default one.

On this note we will round up, meet again another day, another time! No repository this time, because all code placed in article — as I sad almost no code.

Happy coding and testing! \ (•◡•) /

First of all you need to setup and run Selenoid on your environment. It can be easily done follow official documentation.

We going fast way, so let’s use Configuration Manager for it.

./cm selenoid start

After some time as result we have Selenoid stated and it’s ready to run your tests against and tests endpoint is — http://localhost:4444/wd/hub

Now Selenide’s turn. As I said before we going to look on two integration options. First — single line configuration.

Let’s create a test project and integrate, integrate, integrate… I will use Gradle as a build tool and JUnit5 as a testing framework.

Add JUni5 — testImplementation("org.junit.jupiter:junit-jupiter:5.4.2")

Add Selenide — testImplementation("com.codeborne:selenide:5.2.3")

In very simple case we just need to tell Selenide run tests against remote web driver by adding single line:

Configuration.remote = "http://localhost:4444/wd/hub";

Also don’t forget to disable WebDriverManager:

Configuration.driverManagerEnabled = false;

And put it to test setup block:

@BeforeEach
void setUp() {
  Configuration.driverManagerEnabled = false;
  Configuration.remote = "http://localhost:4444/wd/hub";
}

Create simple test and execute it:

@Test                           
void ableToRunDefaultDriverOnSelenoid() {
  open("https://www.google.com");
  assertEquals(title(), "Google");
}

As result in logs we can see that session was created inside Selenoid container as RemoteWebDriver:

INFO: BrowserName=chrome Version=74.0.3729.157 Platform=LINUX
INFO: Create webdriver in current thread 1: RemoteWebDriver -> RemoteWebDriver: chrome on LINUX (23b5bb5746fdc8cc16b7f850e9080092)

Perfect!

But what if we need to create a custom WebDriver? And Selenide has such ability. It’s described in Selenide Wiki on GitHub. In my case I just want to execute tests on Firefox and accept insecure certificates:

public static class CustomProvider implements WebDriverProvider {
  @Override
  public WebDriver createDriver(DesiredCapabilities capabilities) {
    FirefoxOptions firefoxOptions = new FirefoxOptions();
    firefoxOptions.setAcceptInsecureCerts(true);
    firefoxOptions.merge(capabilities);
    try {
      return new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), firefoxOptions);
    } catch (final MalformedURLException e) {
        throw new RuntimeException("Unable to create driver", e);
    }
  }
}

Also don’t forget to disable WebDriverManager and set custom driver as browser to Selenide:

@BeforeEach
void setUp() {
  Configuration.driverManagerEnabled = false;
  Configuration.browser = CustomProvider.class.getName();
}

Easy as pie — save, run, relax:

INFO: BrowserName=firefox Version=67.0 Platform=LINUX
INFO: Create webdriver in current thread 1: RemoteWebDriver -> RemoteWebDriver: firefox on LINUX (e5397009-df23–4327–8d69-b031fc10fc3b)

Happy coding and testing! (◕‿◕)

You can find complete project on GitHub.

rosolko/selenide-selenoid-configuration

Few steps but so much pain in the process…

Checklist:

1. Create Bintray account
2. Modify build script
3. Publish to local repository and validate publication
4. Enable automatic signing on upload on Bintray repository
5. Publish artifact to Bintray
6. Synchronize publication with JCenter repository
7. Check availability
8. Create an account on Sonatype JIRA
9. Create ticket and wait until ticket will be resolved with “Central sync is activated for <your space>” reason
10. Wait for 4–5 hour or even better for 1 day
11. Synchronize publication with Maven Central repository
12. Check availability
13. Cheers!

My story was started right after completion of small library. Some time after I ask myself — how do I distribute this library?

Based on my previous experience I prefer to JitPack because this way simple as much as possible.

Just find your library, modify you build script and use it. The problem is — additional repository in your build script. Not all people want to resolve one more additional repository in a target project.

The second problem — I should somehow care about versioning. This case I can only associate artifact version with branch, commit, or release.

As result I got a Gradle build script looks like:

repositories {
  maven { url 'https://jitpack.io' }
}

dependencies {
  implementation 'com.github.rosolko:wdm4j:master-SNAPSHOT'
}

Next I’m trying to use a JFrog Bintray to publish artifacts (bonus of this option — ability to sync artifacts with maven central repository). Registration with my GitHub account allows me to create a free account for open source using. Right after — create a repository, let’s call it maven with Maven type. For now — that’s it.

This case we need to modify our build script, so — let’s do it!

First of all we need to add maven-publish plugin and define several fields to successfully publish valid artifacts. Deep documentation you can find in Gradle publish documentation.

apply plugin: "maven-publish"

Next register tasks that build and collect artifacts:

tasks.register("sourcesJar", Jar) {
    from sourceSets.main.allJava
    classifier "sources"
}

tasks.register("javadocJar", Jar) {
    from javadoc
    classifier "javadoc"
}

Next to we need to create a publishing:

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            artifact sourcesJar
            artifact javadocJar
            pom {
                name = "wdm4j"
                description = "WebDriver binary manager for java"
                url = "https://github.com/rosolko/wdm4j"
                licenses {
                    license {
                        name = "MIT"
                        url = "https://github.com/rosolko/wdm4j/blob/master/LICENSE"
                    }
                }
                developers {
                    developer {
                        id = "rosolko"
                        name = "Aliaksandr Rasolka"
                        email = "rosolko@gmail.com"
                    }
                }
                scm {
                    connection = "scm:git:https://github.com/rosolko/wdm4j.git"
                    developerConnection = "scm:git:https://github.com/rosolko/wdm4j.git"
                    url = "https://github.com/rosolko/wdm4j"
                }
            }
        }
    }
}

Right after that we configure bintray:

bintray {
    user = project.hasProperty('bintrayUser') 
    key = project.hasProperty('bintrayApiKey')
    publications = ['mavenJava']
    pkg {
        repo = 'maven'
        name = 'wdm4j'
        vcsUrl = 'https://github.com/rosolko/wdm4j.git'
        licenses = ['MIT']
    }
}

After that we can execute publishToMavenLocal task, check that we have valid artifacts, and perform bintrayUpload task to upload.

As result library should appear in previously created repository. And of cource we receive an ability to link library with jcenter.

After some indexing time it will appear and available for use:

repositories {
  jcenter
}

dependencies {
  implementation 'com.github.rosolko:wdm4j:1.0.0'
}

On this step we can stop, but bintray has an ability to sync artifacts with maven central repository, why not. Let’s set this up.

On this step problems will starts. For first you can’t easily create account and publish something.

For this sonatype have a special guide, short list:

1. Create JIRA account for sonatype
2. Open an issue to create your space for library upload
3. Sign your artifacts
4. Upload

If with first two points there are no problem — signing can be quite tricky, but bintray allows you to configure repository with automatic GPG signing uploaded files using Bintray’s public/private key pair.

Right after that upload your artifacts again and sync library repository with Maven Central.

For this operation you also need key and token. Sync, release and repository when sync done and wait.

Note: The responsiveness of the Maven Central gateway at Sonatype fluctuates. This operation may take several minutes depending on the weather.

As result you library will appear on maven search portal and you can use it in your build script without modifying your existing repository list:

repositories {
  mavenCentral()
}

dependencies {
  implementation 'com.github.rosolko:wdm4j:1.0.0'
}

Yay, quest complete, you are awesome ~(* — *)~

Complete build scripts and library itself you can easily find on GitHub:

rosolko/wdm4j

Day-to-day I’m using Retrofit2 client and all going flawless until I start using call asynchronously and try to chain operations.

First chapter.

So, what I have on start?

API client:

And service that implement this interface:

And use it:

Nothing special but it works. And works well.

Unfortunately new logic required some changes.

Second chapter.

What if you need to login and execute 2 tasks in parallel using access token from login method? This case I decide to use CompletableFuture from Java 8.

On this level I modify only test logic:

So, easy using, not much code changes… but with this implementation I should wrap each standalone future with CompletableFuture and pass lambda with function that execute API call.

Weird. Let’s find some cool solution.

Third chapter.

Search a little… and more… boo — official implementation with documentation :D

Let’s tune this code out. Since I use Gradle — apply required script and fetch library:

implementation("com.squareup.retrofit2:adapter-java8:2.4.0")

Register adapter to your Retrofit:

Tune API client to return ready CompletableFutures:

Modify your service with future workaround. This place you can even handle result and remove try/catch construction:

Finally let’s change out test:

As you can see for direct API call no need to pass functions — awesome.

Now you just need to worry about chain calls :D

Finally cut out results:

1. All API calls async by default.
2. Call will be executed only when you access future data any way. For example future.get() or future.join() methods calls.
3. No need to think about wrapping method with functions in tests.
4. Easily result handling.
5. Less code. A little bit :D

Happy coding and testing! #_#

Previous story:

TIL 4: Enums on steroid

Next story:

Publish java library to JFrog Bintray and Sonatype with Gradle

Image that you write code for “Good People Coffee” company and you need to somehow describe all drinks provided by you company.

This case you just write down simple enum class with drinks list:

public class GoodPeopleCoffeeCompany {
  public enum Drink {
    ESPRESSO,
    TOAST,
    TEA
  }
}

Good. Next you set price for items:

public class GoodPeopleCoffeeCompany {
  public enum Drink {
    ESPRESSO(1),
    TOAST(2),
    TEA(3);

    private final double price;

    Drink(final double price) {
      this.price = price;
    }

    public double getPrice() {
      return price;
    }
  }
}

Looks good. This case you can easily access drink price and do what ever you want. But image, your businesses grow fast and some day you offer 40% discount for users. Let’s do it:

public static void main(String[] args) {
  final double discount = 0.6;
  final Drink drink = Drink.valueOf(args[0]);
  final double finalPrice = drink.getPrice() * discount;
}

Look good too. But… what if only tea will got discount with 40%? You code get additional verification statement for tea:

public static void main(String[] args) {
  final double teaDiscount = 0.6;
  final Drink drink = Drink.valueOf(args[0]);
  final double initialPrice = drink.getPrice();
  final double finalPrice = drink.equals(Drink.TEA) 
    ? initialPrice * teaDiscount
    : initialPrice;
}

Hm… let it be. What if next week espresso also will be on discount with, but only for 20%? Change you enum a little.

enum Drink {
  ESPRESSO(1, 0.8),
  TOAST(2, 1),
  TEA(3, 0.6);

  private final double price;
  private final double discount;

  Drink(final double price, final double discount) {
    this.price = price;
    this.discount = discount;
  }

  public double getPrice() {
    return price;
  }

  public double getDiscount() {
    return discount;
  }
}

And get discounted price:

public static void main(String[] args) {
  final Drink drink = Drink.valueOf(args[0]);
  final double initialPrice = drink.getPrice();
  final double finalPrice = drink.getPrice() * drink.getDiscount();
}

Well. “I thinks enough — looks good”. But!!1 Hell no, what you will do if database?! It’s easy, just tune you enum again:

enum Drink {
  ESPRESSO(DataBase.getEspressoPrice(), 
   DataBase.getEspressoDiscout()),
  TOAST(DataBase.getToastPrice(), DataBase.getToastDiscout()),
  TEA(DataBase.getTeaPrice(), DataBase.getTeaDiscout());

  private final double price;
  private final double discount;

  Drink(final double price, final double discount) {
    this.price = price;
    this.discount = discount;
  }

  public double getPrice() {
    return price;
  }

  public double getDiscount() {
    return discount;
  }
}

Cool. But, what if dev, test, uat, prod environments? What if DEPENDENCY INJECTION??1

Houston, we got a problem!

Can’t properly inject to static class. Lets refactor this weird enum!

In this case — I will create service that calculate final price for me. Let’s call it PriceService . As long as service class isn’t static — I can easily inject database class.

Create price service:

class PriceService {
  @Inject
  private DataBase dataBase;

  double computeEspressoPrice(final double discount) {
    return dataBase.getEspressoPrice() * discount;
  }

  double computeToastPrice(final double discount) {
    return dataBase.getToastPrice() * discount;
  }

  double computeTeaPrice(final double discount) {
    return dataBase.getTeaPrice() * discount;
  }

  double computePrice(final Drink drink, double discount) {
    return drink.getPrice().apply(this, discount);
  }
}

Add bi-function to enum:

enum Drink {
  ESPRESSO(PriceService::computeEspressoPrice),
  TOAST(PriceService::computeToastPrice),
  TEA(PriceService::computeTeaPrice);

  public final BiFunction<PriceService, Double, Double> price;

  Drink(BiFunction<PriceService, Double, Double> price) {
   this.price = price;
  }

  public BiFunction<PriceService, Double, Double> getPrice() {
    return price;
  }
}

Use it:

class MainClass {
  @Inject
  private PriceService priceService;

  public void main(String[] args) {
    final Drink drink = Drink.valueOf(args[0]);
    final double finalPrice = priceService.computePrice(drink, 0.6);
  }
}

Welp! But, again — I must manually pass discount :( Don’t worry — just use function instead of bi-function. Reduce function parameter and get discount from database.

New enum:

enum Drink {
  ESPRESSO(PriceService::computeEspressoPrice),
  TOAST(PriceService::computeToastPrice),
  TEA(PriceService::computeTeaPrice);

  public final Function<PriceService, Double> price;

  Drink(Function<PriceService, Double> price) {
    this.price = price;
  }

  public Function<PriceService, Double> getPrice() {
    return price;
  }
}

New price service:

class PriceService {
  @Inject
  private DataBase dataBase;

  double computeEspressoPrice() {
    return dataBase.getEspressoPrice() * 
      dataBase.getEspressoDiscout();
  }

  double computeToastPrice() {
    return dataBase.getToastPrice() * 
      dataBase.getToastDiscout();
  }

  double computeTeaPrice() {
    return dataBase.getTeaPrice() * 
      dataBase.getTeaDiscout();
  }

  double computePrice(final Drink drink) {
    return drink.getPrice().apply(this);
  }
}

Use it:

class MainClass {
  @Inject
  private PriceService priceService;

  public void main(String[] args) {
    final Drink drink = Drink.valueOf(args[0]);
    final double finalPrice = priceService.computePrice(drink);
  }
}

Finally, you have flexible implementation that allow you to use any data base provider and any price service, so easy to switch, easy to test, easy to mock.

Easy to customize price calculation for each enum value type. Like:

class EnchancedPriceService {
  @Inject
  private DataBase dataBase;

  double computeEspressoPrice() {
    return dataBase.getEspressoPrice()
     * dataBase.getToastDiscout()
     * 0.1;
  }

  double computeToastPrice() {
    return dataBase.getToastPrice() 
      * dataBase.getToastDiscout()   
      - 10;
  }

  double computeTeaPrice() {
    return dataBase.getTeaPrice() 
      * dataBase.getTeaDiscout() 
      / 2;
  }

  double computePrice(final Drink drink) {
    return drink.getPrice().apply(this);
  }
}

Even, if you add some new value to enum this construction require you to add method implementation for price service:

New enum value:

enum Drink {
  MILK(PriceService::computeMilkPrice);
}

Create calculate method in price service:

class PriceService {
  @Inject
  private DataBase dataBase;

  double computeMilkPrice() {
    return dataBase.getMilkPrice() * dataBase.getMilkDiscout();
  }
}

Perfect!

Happy codding, made you test a little functional! D_D

Previous story:

TIL 3: Dependabot, GreenMail and Selenide JUnit5 extensions

Next story:

TIL 5: Made your retrofit rest client reactive a little bit.

Dependabot — quite simple but extremely useful GitHub extension that allow you to keep your project dependencies up-to-date.

Just app application to you GitHub account and give permission for target repository and set-up pooling interval.

And when some library will update — bot automatically create new pull request with updates.

You can also use a lot of commands for manage behavior — here is a list of:

Next this — it’s JUnit4 rule to JUnit5 extension migration. As example I’ll show you Selenide soft asserts rule.

By default Selenide can assert softly only for TestNG or Junit4, but since JUnit5 drop rule support — it’s impossible to use old rule for that.

So, what we have — Junit4 rule:

As we can see in this rule actions applying on before and after levels, so let’s find out what we can use from JUnit5.

We also want to apply actions for each test, so let’s implement BeforeEachCallback and AfterEachCallback extension endpoints and create an extension:

As you can see — I’ve made some changes across original rule:

1. Move errorCollector initialization to constructor — it’s linked with extension using, there are 2 way to use extension:

The first one:

@ExtendWith(SoftAssertsExtension.class)

In this case all going flawless without any problems.

And the second one:

@RegisterExtension 
SoftAssertsExtension assertsExtension = new SoftAssertsExtension();

And for this case I’ve move initialization to constructor. I’m using it for tests, that’s also have some interesting points. Also in future — it’s will allow to add parameterized constructor and property use it.

2. Add gerErrorCollector method to test asserts — it needed to check that all errors will collect and throw for current test:

And check test console output:

Perfect!

I’m also add JUnit5 extension for GreenMail and it’s also copy logic from original Junit4 rule.

You take get and try both extensions by links:

• rosolko/greenmail-junit5
• rosolko/selenide-junit5

Previous story:

TIL 2: Win against Appium, new Selenium version, Gradle BOM and more…

Next story:

TIL 4: Enums on steroid

Last week I upgrade Appium to 1.8.0 version and face “Keyboard is not present” issue and now looks like I found solution.

You just need to execute 2 scripts before test run, for example as a pre step on your CI:
1. defaults write com.apple.iphonesimulator ConnectHardwareKeyboard 1

2. defaults write com.apple.iphonesimulator ToggleSoftwareKeyboard 1

As I understood iOS 11.3 and latest Appium required keyboard to be displayed all the time. So if keyboard hide some element you should tune your test to hide keyboard or swipe a little until element visible.

I’m consider to swipe for now. Code that I’m using:

public enum Direction {
    UP,
    DOWN,
    RIGHT,
    LEFT
}

private void swipe(final Direction direction) {
    final Map<String, Object> params = new HashMap<>();
    params.put("direction", direction.name().toLowerCase());
    getIosDriver().executeScript("mobile: swipe", params);
}

As you know or not — selenium released 3.12.0 version. So I try to update it for my project and got strange error during mobile driver initialization:

java.lang.NoSuchMethodError: org.openqa.selenium.json.JsonOutput.write(Ljava/lang/Object;Ljava/lang/reflect/Type;)Lorg/openqa/selenium/json/JsonOutput;
at org.openqa.selenium.remote.NewSessionPayload.writeTo(NewSessionPayload.java:247)

...

Suppressed: java.io.IOException: Incomplete document
 at com.google.gson.stream.JsonWriter.close(JsonWriter.java:559)
 at org.openqa.selenium.json.JsonOutput.close(JsonOutput.java:38)
 at org.openqa.selenium.remote.NewSessionPayload.writeTo(NewSessionPayload.java:270)

Okay. Let’s wait for new Appium release.

This week I’m also create a short guide how to configure Allure 2 for Gradle with some extra tools. Here it is.

Finally I’m implement BOM imports for my project that’s was introduces in Gradle version 4.6. It’s simple.

For fist — add enable this feature preview for Gradle. Let’s it in settings.gradle:

enableFeaturePreview('IMPROVED_POM_SUPPORT')

Next — improve your build script. Note: not all libraries already support this features, but JUnit5 and Log4j2 does:

Old dependencies section:

ext {
    log4jVersion = '2.11.0'
    junitJupiterVersion = '5.2.0'
}

...

dependencies {
    api("org.apache.logging.log4j:log4j-api:$log4jVersion")
 
    testImplementation("org.junit.jupiter:junit-jupiter-api:$junitJupiterVersion")
    testImplementation("org.junit.jupiter:junit-jupiter-params:$junitJupiterVersion")

testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:$junitJupiterVersion")
    testRuntimeOnly("org.apache.logging.log4j:log4j-core:$log4jVersion")
    testRuntimeOnly("org.apache.logging.log4j:log4j-jul:$log4jVersion")
    testRuntimeOnly("org.apache.logging.log4j:log4j-jcl:$log4jVersion")
    testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j-impl:$log4jVersion")
}

Becomes to new one:

dependencies {
    api("org.apache.logging.log4j:log4j-bom:2.11.0")
    api("org.apache.logging.log4j:log4j-api")

    testImplementation("org.junit:junit-bom:5.2.0")
    testImplementation("org.junit.jupiter:junit-jupiter-api")
    testImplementation("org.junit.jupiter:junit-jupiter-params")

    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
    testRuntimeOnly("org.apache.logging.log4j:log4j-core")
    testRuntimeOnly("org.apache.logging.log4j:log4j-jul")
    testRuntimeOnly("org.apache.logging.log4j:log4j-jcl")
    testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j-impl")
}

From my point of view configuration become more easier.

Also I found that session can be also signed using browser local storage instead of cookie.

Previous story:

TIL 1: New versions of Appium and Windows, Gradle fail fast feature

Next story:

TIL 3: Dependabot, GreenMail and Selenide JUnit5 extensions

Previously I talk about fast authorization via cookie. But now, I found one more variant — it’s a browser local storage.

Mechanism look like cookie, but we need to change our JavaScript code a little.

Last time I use duplicated code and it’s look kinda weird. Let’s upgrade it!

Leave old JavaScript executor and open methods untouched:

private void executeJavaScript(final String jsCode) {
    ((JavascriptExecutor) webDriver).executeScript(jsCode);
}

private void open(final String url) {
    webDriver.get(url);
}

Create private method that set name value in local storage:

private void setItemInLocalStorage(final String item, final String value) {
  final String jsCode = String.format(
    "window.localStorage.setItem('%s','%s');", 
    item, 
    value);

  executeJavaScript(jsCode);
}

Create a new public method that will authorize application:

public void authorizeWithLocalStorage(final AccessToken accessToken) {
  open("https://my-supa-dupa-app.com/robots.txt");

  setItemInLocalStorage("$accessTokenId", accessToken.getId());
  setItemInLocalStorage("$currentUserId", accessToken.getUserId());
}

Works as expected stable and fast. Awesome!

Happy testing! ~_~

For first you need to apply allure gradle plugin. I’m using latest gradle version so let’s use new plugin applying mechanism.

plugins {
    id 'io.qameta.allure' version '2.8.1'
}

Next step will be about configuration. In my test I’m using Junit5 and I want to use latest allure version so I’ll manually pass latest version in config and also I have to use custom download link format to get a latest version of allure commandline.

allure {
    version = '2.14.0'
}

Last but not least — tools integration. There are many of integration, I’m showing my set:

1. Junit5
2. Selenide
3. Retforit/Okhttp

I’m going to apply this integration as dependencies.

Retforit/Okhttp. I’m using implementation scope because it’s required some code changes to work property:

dependencies {
    implementation('io.qameta.allure:allure-okhttp3:2.14.0')
}

Code changes — it’s just additional Okhttp client interceptor:

final AllureOkHttp3 allureOkHttp3 = new AllureOkHttp3();

final OkHttpClient okHttpClient = new OkHttpClient.Builder()
    .addInterceptor(allureOkHttp3)
    .build();

Junit5 integration isn’t required any code changes, just place it in right scope, use testRuntimeOnly scope for that:

dependencies {
    testRuntimeOnly('io.qameta.allure:allure-junit5:2.14.0')
}

That’s all.

Selenide integration also required some code changes, but lets apply testImplementation scope because it’s required only SelenideLogger listener registration that can be done before tests:

dependencies {
    testImplementation('io.qameta.allure:allure-selenide:2.14.0')
}

Code changes — add listener on BeforeAll step:

@BeforeAll
public void setUp() {
    SelenideLogger.addListener("allure", new AllureSelenide());
}

And don’t forget to remove listener after tests. Let’s do it on AfterAll step:

@AfterAll
public void tearDown() {
    SelenideLogger.removeListener("allure");
}

I’m also advise to create allure property file and point results directory to avoid miss target results creation. I’m place it inside src/test/resources folder and call it allure.properties and add content:

allure.results.directory=build/allure-results

Great! Now you’re all done.

From now you just need to execute your test and after tests run gradle task allureReport that creates Allure report or allureServethat creates Allure report and opens it in the default browser.

Happy testing! D_D

You can find complete project on GitHub.

rosolko/allure-gradle-configuration

Gradle introduce failFast feature in 4.6 version and it’s super useful if you don’t want to wait a lot for tests complete and fail build as fast as possible if something going wrong.

On my project I’m applying this option to test and check for Pull and Merge Requests during CI builds where I don’t care about all failures and where even one failed test fail request.

Just bypass extra parameter: ./gradlew check test --fail-fast

Or you can use it on regular base by tuning test task:

test {
    failFast = true
}

14 days after release I’m decide to update automation stack with new Xcode to 9.3 version and transitive iOS Simulator to 11.3 verison.

As claimed in release notes 1.8.0 version bring Support for iOS 11.3/Xcode 9.3

So, update all things, run tests… and catch fast exception:

org.openqa.selenium.WebDriverException: An unknown server-side error occurred while processing the command. Original error: Error Domain=com.facebook.WebDriverAgent Code=1 “Keyboard is not present” UserInfo={NSLocalizedDescription=Keyboard is not present}

Research a lot… and research… and research… There are no solution for now :(

Solution from issues won’t work.

Issue references:

1. Appium github #8412
2. Github Facebook WebDriverAgent #574

So, decide to downgrade Appium to 1.7.2 version — and it’s work! Even with latest version of iOS/Xcode.

Waiting to next releases.

Update: Work well now… *magic*

Windows 10 April 2018 update. Last but not least.

If your microphone won’t work just check enabled option under Settings > Privacy > Microphone > Allow apps to access your microphone to save you time and nerves.

I don’t know why, but this option was disabled after update :C

Next story

TIL 2: Win against Appium, new Selenium version, Gradle BOM and more…