Appium 三种wait方法（appium 学习之改造*）

前些日子，配置好了appium测试环境，至于环境怎么搭建，参考：http://www.cnblogs.com/tobecrazy/p/4562199.html

　　　　　　　　　　　　　　　   　　知乎Android客户端登陆：http://www.cnblogs.com/tobecrazy/p/4579631.html

appium实现截图和清空EditText:  http://www.cnblogs.com/tobecrazy/p/4592405.html

学过selenium的都知道，一般等待元素加载有三种办法:

• sleep                  Thread.sleep（60000） 强制等待60s
• implicitlyWait      

   driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);  

  隐式等待，全局等待30s不管元素是否已经加载

• WebDriverWait     显示等待，这个需要增加一定等待时间，显示等待时间可以通过WebDriverWait 和util来决定,比如这个timeOut是60，如果该元素60s以内出现就不在等待

WebDriverWait wait = new WebDriverWait(driver, 60);
    WebElement e= wait.until(new  ExpectedCondition<WebElement>() {
            @Override
            public WebElement apply(WebDriver d) {
                return d.findElement(By.id("q"));
            }
        })

以上三种方法中，只用WebDriverWait是selenium所特有，在java-client中也找不到相应，如果想使用这种方法怎么办？

改造*，首先添加AndroidDriverWait.java, 其实是将WebDriverWait的类型改成AndroidDriverWait

具体代码如下：

　　

 package com.dbyl.core;

 /*
 Copyright 2007-2009 Selenium committers

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
  */

 import org.openqa.selenium.NotFoundException;
 import org.openqa.selenium.TimeoutException;
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.WebDriverException;
 import org.openqa.selenium.remote.RemoteWebDriver;
 import org.openqa.selenium.support.ui.Clock;
 import org.openqa.selenium.support.ui.FluentWait;
 import org.openqa.selenium.support.ui.Sleeper;
 import org.openqa.selenium.support.ui.SystemClock;

 import io.appium.java_client.android.AndroidDriver;

 import java.util.concurrent.TimeUnit;

 /**
  * A specialization of {@link FluentWait} that uses WebDriver instances.
  */
 public class AndroidDriverWait extends FluentWait<AndroidDriver> {
   public final static long DEFAULT_SLEEP_TIMEOUT = 500;
   private final WebDriver driver;

   /**
    * Wait will ignore instances of NotFoundException that are encountered (thrown) by default in
    * the 'until' condition, and immediately propagate all others.  You can add more to the ignore
    * list by calling ignoring(exceptions to add).
    *
    * @param driver The WebDriver instance to pass to the expected conditions
    * @param timeOutInSeconds The timeout in seconds when an expectation is called
    * @see AndroidDriverWait#ignoring(java.lang.Class)
    */
   public AndroidDriverWait(AndroidDriver driver, long timeOutInSeconds) {
     this(driver, new SystemClock(), Sleeper.SYSTEM_SLEEPER, timeOutInSeconds, DEFAULT_SLEEP_TIMEOUT);
   }

   /**
    * Wait will ignore instances of NotFoundException that are encountered (thrown) by default in
    * the 'until' condition, and immediately propagate all others.  You can add more to the ignore
    * list by calling ignoring(exceptions to add).
    *
    * @param driver The WebDriver instance to pass to the expected conditions
    * @param timeOutInSeconds The timeout in seconds when an expectation is called
    * @param sleepInMillis The duration in milliseconds to sleep between polls.
    * @see AndroidDriverWait#ignoring(java.lang.Class)
    */
   public AndroidDriverWait(AndroidDriver driver, long timeOutInSeconds, long sleepInMillis) {
     this(driver, new SystemClock(), Sleeper.SYSTEM_SLEEPER, timeOutInSeconds, sleepInMillis);
   }

   /**
    * @param driver The WebDriver instance to pass to the expected conditions
    * @param clock The clock to use when measuring the timeout
    * @param sleeper Object used to make the current thread go to sleep.
    * @param timeOutInSeconds The timeout in seconds when an expectation is
    * @param sleepTimeOut The timeout used whilst sleeping. Defaults to 500ms called.
    */
   public AndroidDriverWait(AndroidDriver driver, Clock clock, Sleeper sleeper, long timeOutInSeconds,
       long sleepTimeOut) {
     super(driver, clock, sleeper);
     withTimeout(timeOutInSeconds, TimeUnit.SECONDS);
     pollingEvery(sleepTimeOut, TimeUnit.MILLISECONDS);
     ignoring(NotFoundException.class);
     this.driver = driver;
   }

   @Override
   protected RuntimeException timeoutException(String message, Throwable lastException) {
     TimeoutException ex = new TimeoutException(message, lastException);
     ex.addInfo(WebDriverException.DRIVER_INFO, driver.getClass().getName());
     if (driver instanceof RemoteWebDriver) {
       RemoteWebDriver remote = (RemoteWebDriver) driver;
       if (remote.getSessionId() != null) {
         ex.addInfo(WebDriverException.SESSION_ID, remote.getSessionId().toString());
       }
       if (remote.getCapabilities() != null) {
         ex.addInfo("Capabilities", remote.getCapabilities().toString());
       }
     }
     throw ex;
   }
 }

接着需要修改接口：ExpectedCondition，将其WebDriver的类型替换为AndroidDriver

具体代码：

 /*
 Copyright 2007-2009 Selenium committers

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
  */

 package com.dbyl.core;

 import io.appium.java_client.android.AndroidDriver;

 import com.google.common.base.Function;

 /**
  * Models a condition that might reasonably be expected to eventually evaluate to something that is
  * neither null nor false. Examples would include determining if a web page has loaded or that an
  * element is visible.
  * <p>
  * Note that it is expected that ExpectedConditions are idempotent. They will be called in a loop by
  * the {@link WebDriverWait} and any modification of the state of the application under test may
  * have unexpected side-effects.
  *
  * @param <T> The return type
  */
 public interface ExpectedCondition<T> extends Function<AndroidDriver, T> {}

经过修改之后，就可以在appium中直接使用：

        //wait for 60s if WebElemnt show up less than 60s , then return , until 60s
        WebElement showClose = new AndroidDriverWait(driver, 60)
                .until(new ExpectedCondition<WebElement>() {
                    public WebElement apply(AndroidDriver d) {
                        return d.findElement(By
                                .id("com.zhihu.android:id/showcase_close"));
                    }

                });

---

个人心得：

做自动化也有4年多，之前做的是server端的测试，并未太多的关注过selenium，现在selenium上面的积累已经一年多，

起初学东西是拿来用，不知其原理，只知道这么用，长期以来，并未有什么进步。最近看到一些大牛分享的学习思路，才发现学东西要循序渐进，

学会使用->熟练使用->了解掌握其原理->分析改造源码->造*

经过这一系列的学习和总结，就能成为资深人士。