聲明：本文搬運(yùn)自官方操作文檔，僅用作學(xué)習(xí)，有錯(cuò)誤的地方歡迎指正。
官方文檔鏈接：RobotFramework--擴(kuò)展Robot Framework

4 擴(kuò)展Robot Framework

4.1 創(chuàng)建測試庫

4.1.1 介紹

支持的編程語言

Robot Framework本身是用Python編寫的，測試庫自然可以使用Python實(shí)現(xiàn)擴(kuò)展。在Jython上運(yùn)行時(shí)，庫也可以用Java執(zhí)行。純 Python 代碼在 Python 和 Jython 上都有效， 但是如果不使用Jython的語法和模塊就不能運(yùn)行在Jython上。使用 Python 時(shí)，使用Python C API也能用 C 實(shí)現(xiàn)庫，但是使用ctypes模塊通常更容易與 Python 庫的 C 代碼交互。

使用這些本機(jī)支持的語言執(zhí)行的庫也可以充當(dāng)使用其他編程語言實(shí)現(xiàn)的功能的包裝器。這種方法的一個(gè)很好的例子是Remote庫，另一個(gè)廣泛使用的方法是運(yùn)行外部腳本或工具作為單獨(dú)的進(jìn)程。

提示
RobotFramework測試庫開發(fā)人員的 Python 教程涵蓋了足夠的 Python 語言， 開始使用它編寫測試庫。還包含一個(gè)簡單的示例庫和測試案例，可以在計(jì)算機(jī)上執(zhí)行和以其他方式進(jìn)行研究。

不同的測試庫API

Robot Framework有三種不同的測試庫 API。

靜態(tài)API
最簡單的方法是有一個(gè)模塊（在Python）或一個(gè)類（在Python或Java），其方法直接映射到關(guān)鍵字名稱。關(guān)鍵字也采用與執(zhí)行它們的方法相同的參數(shù)。關(guān)鍵字報(bào)告故障時(shí)通過編寫到標(biāo)準(zhǔn)輸出進(jìn)行日志記錄，并且可以使用return語句返回值。
動態(tài)API
動態(tài)庫是實(shí)現(xiàn)獲取其執(zhí)行的關(guān)鍵字名稱的方法的類，以及執(zhí)行帶有給定參數(shù)的指定關(guān)鍵字的另一種方法。要執(zhí)行的關(guān)鍵字的名稱以及執(zhí)行方式可以在運(yùn)行時(shí)動態(tài)確定，但報(bào)告狀態(tài)、記錄和返回值的工作與靜態(tài) API 類似。
混合API
這是靜態(tài)和動態(tài) API 之間的混合體。庫是帶有說明其執(zhí)行的關(guān)鍵字的方法的類，但這些關(guān)鍵字必須直接可用。除了發(fā)現(xiàn)實(shí)現(xiàn)哪些關(guān)鍵字之外，其他一切都與靜態(tài) API 中類似。

所有這些 API 都在此章節(jié)中進(jìn)行了描述。一切都基于靜態(tài) API 的工作原理，因此首先討論其功能。動態(tài)庫 API和混合庫 API與它有什么不同，然后在他們自己的部分討論。

本章中的例子主要是關(guān)于使用 Python 的，但對于Java開發(fā)人員來說也很容易理解。在少數(shù) API 有差異的情況下，這兩種用法都用充分的例子來解釋。

4.1.2創(chuàng)建測試庫類或模塊

測試庫可以作為 Python 模塊和 Python 或 Java 類執(zhí)行。

測試庫名稱

導(dǎo)入庫時(shí)使用的測試庫的名稱與執(zhí)行該庫的模塊或類的名稱相同。例如，如果你有一個(gè)Python模塊MyLibrary（即文件*MyLibrary.py），它將創(chuàng)建一個(gè)庫的名字MyLibrary。同樣，Java 類YourLibrary，當(dāng)它不在任何包中時(shí)，創(chuàng)建一個(gè)完全具有該名稱的庫。

Python 類始終在模塊內(nèi)。如果執(zhí)行庫的類的名稱與模塊的名稱相同，則Robot Framework允許在導(dǎo)入庫時(shí)刪除模塊名稱。例如，MyLib.py文件中的MyLib類可以用作具有*MyLib*名稱的庫。如果模塊名稱和類名稱不同，則必須使用模塊和類名稱（如mymodule.MyLibrary）。

必須使用非默認(rèn)包中的 Java 類，并使用全名。例如com.mycompany.myproject包中的MyLib類必須輸入名稱*com.mycompany.myproject.MyLib*。

提示
如果庫名真的很長，例如當(dāng) Java 包名稱很長時(shí)，建議使用WITH NAME 語法給庫提供更簡單的別名。

規(guī)定測試庫參數(shù)

作為類執(zhí)行的所有測試庫都可以攜帶參數(shù)。這些參數(shù)在庫名之后的"設(shè)置"表中指定，當(dāng)Robot Framework創(chuàng)建導(dǎo)入庫的實(shí)例時(shí)，它將它們傳遞給其構(gòu)造者。作為模塊實(shí)現(xiàn)的庫不能接受任何參數(shù)，如果使用會報(bào)錯(cuò)。

庫所需的參數(shù)數(shù)與庫的構(gòu)造者接受的參數(shù)數(shù)相同。默認(rèn)值和可變參數(shù)數(shù)與關(guān)鍵字參數(shù)類似，但 Java 庫沒有可變參數(shù)支持。傳遞給庫的參數(shù)以及庫名稱本身可以使用變量進(jìn)行指定，因此可以從命令行中更改。

導(dǎo)入帶參數(shù)的測試庫

image.png

示例實(shí)現(xiàn)，第一個(gè)是 Python，第二個(gè)是 Java ：

from example import Connection

class MyLibrary:

    def __init__(self, host, port=80):
        self._conn = Connection(host, int(port))

    def send_message(self, message):
        self._conn.send(message)

public class AnotherLib {

    private String setting = null;

    public AnotherLib(String setting) {
        setting = setting;
    }

    public void doSomething() {
        if setting.equals("42") {
            // do something ...
        }
    }
}

測試庫作用域

作為類執(zhí)行的庫可以具有內(nèi)部狀態(tài)，可以通過關(guān)鍵字和與庫構(gòu)造者進(jìn)行參數(shù)更改。由于狀態(tài)會影響關(guān)鍵字的實(shí)際行為方式，因此確保一個(gè)測試案例的變化不會影響其他測試案例就非常重要。此類依賴項(xiàng)可能會產(chǎn)生難以驗(yàn)證的問題，例如，當(dāng)添加新的測試案例且它們使用庫不一致時(shí)。

Robot Framework試圖使測試案例彼此獨(dú)立：默認(rèn)情況下，它為每個(gè)測試案例創(chuàng)建新的測試庫實(shí)例。然而，這種行為并不總是可取，因?yàn)橛袝r(shí)測試案例應(yīng)該能夠共享一個(gè)共同的狀態(tài)。此外，所有庫都沒有狀態(tài)，根本不需要?jiǎng)?chuàng)建新的實(shí)例。

測試庫可以控制何時(shí)創(chuàng)建帶有類屬性ROBOT_LIBRARY_SCOPE的新庫。此屬性必須是一個(gè)字符串，它可以具有以下三個(gè)值：

TEST CASE
為每個(gè)測試案例創(chuàng)建一個(gè)新實(shí)例?？赡艿奶准O(shè)置和套件拆解共享另一個(gè)實(shí)例。這是默認(rèn)值。
TEST SUITE
為每個(gè)測試套件創(chuàng)建一個(gè)新實(shí)例。最低級別的測試套件由測試案例文件創(chuàng)建，包含測試案例，具有自己的實(shí)例，而高級套件都擁有自己的實(shí)例，用于可能的設(shè)置和拆解。
GLOBAL
在整個(gè)測試執(zhí)行過程中只創(chuàng)建了一個(gè)實(shí)例，所有測試案例和測試套件都共享該實(shí)例。從模塊創(chuàng)建的庫始終是全局性的。

當(dāng)TEST SUITE或GLOBAL與具有狀態(tài)的測試庫一起使用時(shí)，建議庫具有一些用于清理狀態(tài)的特殊關(guān)鍵字。然后，此關(guān)鍵字可用于套件設(shè)置或拆解中，以確保下一個(gè)測試套件中的測試案例可以從已知狀態(tài)開始。例如，SeleniumLibrary*使用GLOBAL在不同的測試情況下啟用同一瀏覽器，而無需重新打開它，并且它還具有*Close All Browsers*關(guān)鍵字，可輕松關(guān)閉所有打開的瀏覽器。

使用TEST SUITE示例的 Python 庫示例：

class ExampleLibrary:

    ROBOT_LIBRARY_SCOPE = 'TEST SUITE'

    def __init__(self):
        self._counter = 0

    def count(self):
        self._counter += 1
        print self._counter

    def clear_counter(self):
        self._counter = 0

使用GLOBAL范圍的示例Java庫：

public class ExampleLibrary {

    public static final String ROBOT_LIBRARY_SCOPE = "GLOBAL";

    private int counter = 0;

    public void count() {
        counter += 1;
        System.out.println(counter);
    }

    public void clearCounter() {
        counter = 0;
    }
}

指定庫版本

當(dāng)測試庫投入使用時(shí)，Robot Framework會嘗試確定其版本。然后將此信息寫入系統(tǒng)以提供調(diào)試信息。庫文檔工具libdoc還將此信息編寫到它生成的關(guān)鍵字文檔中。

版本信息是從屬性ROBOT_LIBRARY_VERSION讀取的，就像測試庫范圍從ROBOT_LIBRARY_SCOPE讀取一樣。如果ROBOT_LIBRARY_VERSION不存在，則嘗試從__version__屬性讀取信息。這些屬性是類屬性還是模塊屬性，具體取決于庫是作為類還是模塊實(shí)現(xiàn)的。對于 Java 庫，版本屬性必須聲明為static final。

使用__version__的 Python 模塊示例：

__version__ = '0.1'

def keyword():
    pass

使用ROBOT_LIBRARY_VERSION的Java類：

public class VersionExample {

    public static final String ROBOT_LIBRARY_VERSION = "1.0.2";

    public void keyword() {
    }
}

4.1.3 創(chuàng)建靜態(tài)關(guān)鍵字

哪些方法被視為關(guān)鍵字

使用靜態(tài)庫 API 時(shí)，Robot Framework使用反射來找出庫類或模塊執(zhí)行的公共方法。它將排除所有從下劃線開始的方法，Java庫也排除了僅在java.lang.Object中執(zhí)行的方法。所有未被忽略的方法都被視為關(guān)鍵字。例如，下面的 Python 和 Java 庫實(shí)現(xiàn)單個(gè)關(guān)鍵字My Keyword。

class MyLibrary:

    def my_keyword(self, arg):
        return self._helper_method(arg)

    def _helper_method(self, arg):
        return arg.upper()

public class MyLibrary {

    public String myKeyword(String arg) {
        return helperMethod(arg);
    }

    private String helperMethod(String arg) {
        return arg.toUpperCase();
    }
}

當(dāng)庫作為 Python 模塊實(shí)現(xiàn)時(shí)，還可以通過使用 Python 的__all__屬性來限制關(guān)鍵字的方法。如果使用__all__，則其中列出的方法只能是關(guān)鍵字。例如下面的庫實(shí)現(xiàn)關(guān)鍵字Example Keyword和Second Example。如果沒有__all__，它還將實(shí)現(xiàn)關(guān)鍵字Not Exposed As Keyword和Current Thread。__all__最重要的用途是確保導(dǎo)入的幫助方法（如下面示例中的current_thread）不會意外暴露為關(guān)鍵字。

from threading import current_thread

__all__ = ['example_keyword', 'second_example']

def example_keyword():
    if current_thread().name == 'MainThread':
        print 'Running in main thread'

def second_example():
    pass

def not_exposed_as_keyword():
    pass

注意
從RobotFramework 2.5.5 開始支持__all__屬性。

關(guān)鍵字名稱

將測試數(shù)據(jù)中使用的關(guān)鍵字名稱與方法名稱進(jìn)行比較以查找實(shí)現(xiàn)這些關(guān)鍵字的方法。名稱比對不區(qū)分大小寫，空格和下劃線也被忽略。例如，方法hello映射的關(guān)鍵字名稱Hello, hello 甚至h e l l o同樣，do_nothing和doNothing 的方法都可以用作測試數(shù)據(jù)中Do Nothing的關(guān)鍵字。

示例 Python 庫作為MyLibrary.py文件中的模塊實(shí)現(xiàn)：

<pre class="cm-s-default" style="color: rgb(89, 89, 89); margin: 0px; padding: 0px; background: none 0% 0% / auto repeat scroll padding-box border-box rgba(0, 0, 0, 0);">def hello(name): print "Hello, %s!" % name def do_nothing(): pass</pre>

示例 Java 庫在MyLibrary .java文件中作為一個(gè)類實(shí)現(xiàn)：

def hello(name):
    print "Hello, %s!" % name

def do_nothing():
    pass

下面的示例說明了如何使用上述示例庫。如果您想自己嘗試，請確保庫位于庫搜索路徑中。

image.png

關(guān)鍵字參數(shù)

使用靜態(tài)和混合 API，關(guān)鍵字需要多少參數(shù)的信息直接來自實(shí)現(xiàn)它的方法。使用動態(tài)庫 API的庫具有共享此信息的其他方法，因此此部分與它們無關(guān)。

最常見也是最簡單的情況是關(guān)鍵字需要準(zhǔn)確數(shù)量的參數(shù)。在這種情況下，Python 和 Java 方法都只考慮這些論點(diǎn)。例如，執(zhí)行無參數(shù)關(guān)鍵字的方法也不需要參數(shù)，使用一個(gè)參數(shù)實(shí)現(xiàn)關(guān)鍵字的方法也需要一個(gè)參數(shù)，等等。

示例 Python 關(guān)鍵字采取不同數(shù)量的參數(shù)：

def no_arguments():
    print "Keyword got no arguments"

def one_argument(arg):
    print "Keyword got one argument '%s'" % arg

def multiple_arguments(a1, a2, a3):
    print "Keyword got three arguments '%s', '%s' and '%s'" % (a1, a2, a3)

關(guān)鍵字默認(rèn)值

關(guān)鍵字使用帶默認(rèn)值的參數(shù)通常是有用的。Python 和 Java 處理默認(rèn)值的語法不同，在為Robot Framework創(chuàng)建測試庫時(shí)可以使用這些語言的自然語法。

Python默認(rèn)值

在 Python 中方法始終具有一個(gè)實(shí)現(xiàn)，并且方法簽名中指定了可能的默認(rèn)值。所有 Python 程序員都熟悉的語法如下：

def one_default(arg='default'):
    print "Argument has value '%s'" % arg

def multiple_defaults(arg1, arg2='default 1', arg3='default 2'):
    print "Got arguments %s, %s and %s" % (arg1, arg2, arg3)

上面的第一個(gè)示例關(guān)鍵字可以使用零或一個(gè)參數(shù)。如果沒有參數(shù)，arg將獲得值默認(rèn)值。如果有一個(gè)參數(shù)，arg將獲得該值，并且用多個(gè)參數(shù)調(diào)用關(guān)鍵字失敗。在第二個(gè)示例中，始終需要一個(gè)參數(shù)，但第二個(gè)和第三個(gè)參數(shù)具有默認(rèn)值，因此可以使用關(guān)鍵字和一到三個(gè)參數(shù)。

image.png

Java默認(rèn)值

在 Java 中，一種方法可以有幾個(gè)具有不同簽名的實(shí)現(xiàn)。Robot Framework將所有這些實(shí)現(xiàn)視為一個(gè)關(guān)鍵字，可用于不同的參數(shù)。因此，此語法可用于支持默認(rèn)值。下面的示例說明了這一點(diǎn)，該示例在功能上與之前的 Python 示例相同：

public void oneDefault(String arg) {
    System.out.println("Argument has value '" + arg "'");
}

public void oneDefault() {
    oneDefault("default");
}

public void multipleDefaults(String arg1, String arg2, String arg3) {
    System.out.println("Got arguments " + arg1 + ", " + arg2 + " and " + arg3);
}

public void multipleDefaults(String arg1, String arg2) {
    multipleDefaults(arg1, arg2, "default 2");
}

public void multipleDefaults(String arg1) {
    multipleDefaults(arg1, "default 1");
}

參數(shù)的變量數(shù)量

Robot Framework還支持需要任意數(shù)量的參數(shù)的關(guān)鍵字。與默認(rèn)值類似，Python 和 Java 中用于測試庫的實(shí)際語法也不同。

Python參數(shù)的變量數(shù)量

Python 支持接受任意數(shù)量的參數(shù)的方法。同樣的語法在庫中起作用，正如下面的例子所示，它也可以與其他指定參數(shù)的方法相結(jié)合：

def any_arguments(*args):
    print "Got arguments:"
    for arg in args:
        print arg

def one_required(required, *others):
    print "Required: %s\nOthers:" % required
    for arg in others:
        print arg

def also_defaults(req, def1="default 1", def2="default 2", *rest):
    print req, def1, def2, rest

使用帶有參數(shù)變量數(shù)量的關(guān)鍵字

Java參數(shù)的變量數(shù)量

Robot支持Java可變參數(shù)語法來定義參數(shù)的變量數(shù)。Robot還將將數(shù)組翻譯為關(guān)鍵字簽名中的最后一個(gè)參數(shù)，作為參數(shù)的變量數(shù)列表。在這種情況下，關(guān)鍵字的所有剩余參數(shù)都打包到列表中。如果使用的關(guān)鍵字與一個(gè)參數(shù)少于簽名中的實(shí)際參數(shù)數(shù)，這也有效——在這種情況下，末端的陣列將是空的。

Robot對 Java 參數(shù)的變量數(shù)的支持有一個(gè)限制：它僅在方法只有一個(gè)簽名時(shí)才有效。因此，不可能有具有默認(rèn)值和參數(shù)變量的 Java 關(guān)鍵字。當(dāng)然，仍有可能需要的參數(shù)，如下示例所示：

public void anyNumberOfArguments(String... varargs) {
    System.out.println("Got arguments:");
    for (String arg: varargs) {
        System.out.println(arg);
    }
}

public void oneArgumentRequired(String required, String... others) {
    System.out.println("Required: " + required + "\nOthers:");
    for (String arg: others) {
        System.out.println(arg);
    }
}

public void usingAnArray(String[] args) {
    System.out.println("Got arguments:");
    for (String arg: args) {
        System.out.println(arg);
    }
}

參數(shù)類型

通常關(guān)鍵字參數(shù)以字符串的身份出現(xiàn)在Robot Framework中。如果關(guān)鍵字需要其他類型，則可以使用變量或?qū)⒆址D(zhuǎn)換為關(guān)鍵字內(nèi)所需的類型。Java關(guān)鍵字基本類型也自動強(qiáng)制的。

Python的參數(shù)類型

由于 Python 中的參數(shù)沒有任何類型信息，因此在使用 Python 庫時(shí)，不可能自動將字符串轉(zhuǎn)換為其他類型。調(diào)用 Python 方法以使用正確數(shù)量的參數(shù)實(shí)現(xiàn)關(guān)鍵字總是成功的，但如果參數(shù)不兼容，則以后執(zhí)行將失敗。幸運(yùn)的是，Python 將參數(shù)轉(zhuǎn)換為關(guān)鍵字內(nèi)的合適類型非常簡單：

def connect_to_host(address, port=25):
    port = int(port)
    # ...

Java的參數(shù)類型

對 Java 方法的參數(shù)具有類型，并且所有基本類型都自動處理。這意味著測試數(shù)據(jù)中正常字符串的參數(shù)被強(qiáng)制在運(yùn)行時(shí)更正類型。可以強(qiáng)制的類型是：

• 整數(shù)類型（byte, short, int, long)
• 浮點(diǎn)類型（float 和double)
• 布爾類型（boolean）
• 上述類型的對象版本，例如java.lang.Integer

強(qiáng)制是針對關(guān)鍵字方法的所有簽名具有相同或兼容類型的參數(shù)進(jìn)行的。在以下示例中，可對關(guān)鍵字doubleArgument和compatibleTypes進(jìn)行轉(zhuǎn)換，但不能用于conflictingTypes。

public void doubleArgument(double arg) {}

public void compatibleTypes(String arg1, Integer arg2) {}
public void compatibleTypes(String arg2, Integer arg2, Boolean arg3) {}

public void conflictingTypes(String arg1, int arg2) {}
public void conflictingTypes(int arg1, String arg2) {}

如果測試數(shù)據(jù)包含包含數(shù)字的字符串，則強(qiáng)制與數(shù)字類型配合使用，并且與布爾類型一起，數(shù)據(jù)必須包含真或假字符串。只有在原始值是來自測試數(shù)據(jù)的字符串時(shí)才進(jìn)行強(qiáng)制，但當(dāng)然仍可能使用包含 這些關(guān)鍵字正確類型的變量。如果關(guān)鍵字的簽名相互沖突，則使用變量是唯一的選項(xiàng)。

4.1.4 Robot Framework通信

在調(diào)用執(zhí)行關(guān)鍵字的方法后，它可以使用任何機(jī)制與受測試的系統(tǒng)進(jìn)行通信。然后，它還可以向Robot Framework的日志文件發(fā)送消息，將可以保存到變量的信息返回，最重要的是，如果關(guān)鍵字是否通過，則報(bào)告。

報(bào)告關(guān)鍵字狀態(tài)

報(bào)告關(guān)鍵字狀態(tài)可以簡單使用異常來完成。如果執(zhí)行的方法拋了一個(gè)異常，關(guān)鍵字狀態(tài)是FAIL，如果它返回正常，狀態(tài)是PASS。

日志、報(bào)告和控制臺中顯示的錯(cuò)誤消息是從異常類型及其消息創(chuàng)建的。除一般異常（例如AssertionError, Exception, 和 RuntimeError）外，僅使用異常消息，而與其他例外消息一起，創(chuàng)建的消息格式為ExceptionType: Actual message。在這兩種情況下，對于用戶來說，異常信息盡可能詳細(xì)是最重要的。

如果錯(cuò)誤消息長于 40 行，則會自動從中間剪切，以防止報(bào)告過長且難以讀取。完整的錯(cuò)誤消息始終顯示在失敗關(guān)鍵字的日志消息中。

還使用DEBUG 日志級別記錄異常的跟蹤。默認(rèn)情況下，這些消息在日志文件中不可見，因?yàn)樗鼈儗ζ胀ㄓ脩魜碚f用處不大。在開發(fā)庫時(shí)，通常建議使用DEBUG日志級運(yùn)行測試。

停止測試執(zhí)行

從Robot Framework 2.5 開始，測試案例可能會失敗，從而停止整個(gè)測試執(zhí)行。這僅僅是通過在關(guān)鍵字中提出的異常值上設(shè)置具有真實(shí)值的特殊ROBOT_EXIT_ON_FAILURE屬性來完成的。下面的例子說明了這一點(diǎn)。

Python：

class MyFatalError(RuntimeError):
    ROBOT_EXIT_ON_FAILURE = True

Java：

public class MyFatalError extends RuntimeException {
    public static final boolean ROBOT_EXIT_ON_FAILURE = true;
}

失敗后繼續(xù)測試執(zhí)行

從Robot Framework 2.5 開始，即使出現(xiàn)故障也可以繼續(xù)測試執(zhí)行。從測試庫發(fā)出此信號的方法是向用于傳達(dá)故障的異常添加具有真實(shí)值的特殊ROBOT_CONTINUE_ON_FAILURE屬性。以下示例就證明了這一點(diǎn)。

Python：

class MyContinuableError(RuntimeError):
    ROBOT_CONTINUE_ON_FAILURE = True

Java：

public class MyContinuableError extends RuntimeException {
    public static final boolean ROBOT_CONTINUE_ON_FAILURE = true;
}

日志信息

異常消息不是向用戶提供信息的唯一方法。除了它們，方法還可以通過編寫到標(biāo)準(zhǔn)輸出流（Stdout）或標(biāo)準(zhǔn)錯(cuò)誤流（stderr）來發(fā)送消息到日志文件，甚至可以使用不同的日志級別。另一種，而且通常更好是使用程序化日志API記錄日志。

默認(rèn)情況下，通過方法寫入標(biāo)準(zhǔn)輸出的所有內(nèi)容都寫入日志文件，每條日志級別都是INFO。寫入標(biāo)準(zhǔn)錯(cuò)誤的消息處理方式類似，但在關(guān)鍵字執(zhí)行完成后，會回應(yīng)到原始的 stderr。因此，如果您需要一些消息在執(zhí)行測試的控制臺上可見，則可以使用 stderr。

使用日志級別

要使用INFO以外的其他日志級別，或創(chuàng)建多個(gè)消息，通過在格式*LEVEL* Actual log message中嵌入級別來明確指定日志級別，其中*LEVEL*必須在行的開頭，LEVEL有TRACE、DEBUG、INFO、WARN和HTML。

警告

帶有WARN級別的消息會自動寫入控制臺，并寫入日志文件中的單獨(dú)測試執(zhí)行錯(cuò)誤部分。這使得警告比其他消息更明顯，并允許使用它們向用戶報(bào)告重要但非關(guān)鍵問題。

記錄HTML

庫通常記錄的所有內(nèi)容都將轉(zhuǎn)換為可以安全地表示為 HTML 的格式。例如，<b>foo</b>在日志中將顯示與之完全相同的foo。 如果庫想要使用格式、鏈接、顯示圖像等，他們可以使用特殊的偽日志級別HTML。Robot Framework將直接將這些消息與INFO級別一起寫入日志，以便他們可以使用他們想要的任何HTML語法。注意此功能需要小心使用，例如，放置不當(dāng)?shù)?</table>表標(biāo)簽可能會嚴(yán)重破壞日志文件。

使用公共記錄 API時(shí)，各種記錄方法具有可選的html屬性，可設(shè)置為True，以便以 HTML 格式進(jìn)行記錄。

時(shí)間戳

默認(rèn)情況下，通過標(biāo)準(zhǔn)輸出或錯(cuò)誤流記錄的消息在執(zhí)行關(guān)鍵字結(jié)束時(shí)會獲取其時(shí)間戳。這意味著時(shí)間戳不準(zhǔn)確，調(diào)試問題特別是運(yùn)行時(shí)間較長的關(guān)鍵字可能會有問題。

從Robot Framework 2.6 關(guān)鍵字開始，如果需要，可以向其記錄的消息添加準(zhǔn)確的時(shí)間戳。時(shí)間戳單位是毫秒且必須在日志界別之后，以冒號分隔：

*INFO:1308435758660* Message with timestamp
*HTML:1308435758661* <b>HTML</b> message with timestamp

如下所示，使用 Python 和 Java 都很容易添加時(shí)間戳。Python使用程序化日志API更容易獲得準(zhǔn)確的時(shí)間戳。明確添加時(shí)間戳的一大好處是適用于遠(yuǎn)程庫界面

Python：

import time

def example_keyword():
    print '*INFO:%d* Message with timestamp' % (time.time()*1000)

Java：

public void exampleKeyword() {
    System.out.println("*INFO:" + System.currentTimeMillis() + "* Message with timestamp");
}

控制臺輸出日志

如果庫需要向控制臺寫東西，他們有幾個(gè)選項(xiàng)。正如已經(jīng)討論過的那樣，寫入標(biāo)準(zhǔn)錯(cuò)誤流的警告和所有消息都寫入日志文件和控制臺。這兩個(gè)選項(xiàng)都有一個(gè)限制，即消息僅在當(dāng)前執(zhí)行的關(guān)鍵字完成后才結(jié)束到主機(jī)。一個(gè)好處是，這些方法都適用于Python和Java庫。

另一種選擇，即僅適用于 Python，是向sys.__stdout__或sys.__stderr__發(fā)送消息。使用此方法時(shí)，消息會立即寫入控制臺，且不寫入日志文件：

import sys

def my_keyword(arg):
   sys.__stdout__.write('Got arg %s\n' % arg)

最后一種選擇是使用程序化日志API：

from robot.api import logger

def log_to_console(arg):
   logger.console('Got arg %s' % arg)

def log_to_console_and_log_file(arg)
   logger.info('Got arg %s' % arg, also_console=True)

記錄示例

大多數(shù)情況INFO級別是足夠的。更低級別的DEBUG和TRACE是用來記錄調(diào)試信息。這些消息通常不顯示，但它們可以協(xié)助調(diào)試庫本身中可能出現(xiàn)的問題。WARN級別可用于使消息更加可見，如果需要任何格式，則 HTML更好。

以下示例闡明了不同級別日志工作原理。Java 程序員應(yīng)將代碼print 'message'改為System.out.println("message")。

print 'Hello from a library.'
print '*WARN* Warning from a library.'
print '*INFO* Hello again!'
print 'This will be part of the previous message.'
print '*INFO* This is a new message.'
print '*INFO* This is <b>normal text</b>.'
print '*HTML* This is <b>bold</b>.'
print '*HTML* <a >Robot Framework</a>'

16:18:42.123    信息  你好，從圖書館。
16:18:42.123    警告  來自庫的警告。
16:18:42.123    信息  您好！
這將是上一條消息的一部分。
16:18:42.123    信息  這是一條新消息。
16:18:42.123    信息  這是 [lt; b] 正常文本。
16:18:42.123    信息  這是大膽的。
16:18:42.123    信息  機(jī)器人框架

程序化日志API

程序化 API 提供比使用標(biāo)準(zhǔn)輸出和錯(cuò)誤流更清潔的方式來記錄信息。目前，這些接口僅適用于 Python 基礎(chǔ)測試庫。

公共日志API

Robot Framework 2.6有基于 Python 的新型日志API，用于向日志文件和控制臺發(fā)送消息。測試庫可以使用此 API（如logger.info('My message')），而不是通過print '*INFO* My message'等標(biāo)準(zhǔn)輸出進(jìn)行記錄。除了編程界面更加簡潔以外，這個(gè)API有一個(gè)好處就是日志消息有準(zhǔn)確的時(shí)間戳。缺點(diǎn)是，日志API 的測試庫要依賴Robot Framework。

公共日志API 作為 API 文檔的一部分進(jìn)行記錄，下面是一個(gè)簡單的使用示例：

from robot.api import logger

def my_keyword(arg):
    logger.debug('Got argument %s' % arg)
    do_something()
    logger.info('<i>This</i> is a boring example', html=True)
    logger.console('Hello, console!')

使用Python標(biāo)準(zhǔn)logging模塊

除了新的公共日志API，Robot Framework2.6還增加了一個(gè)內(nèi)置的支持Python的標(biāo)準(zhǔn)日志模塊。這樣，模塊的根記錄器接收到的所有消息都會自動傳播到Robot Framework的日志文件中。此外，此 API 會生成具有準(zhǔn)確時(shí)間戳的日志消息，但不支持記錄 HTML 消息或向控制臺發(fā)送消息。好處是此日志 API 不依賴Robot Framework，以下示例也說明了這一點(diǎn)。

import logging

def my_keyword(arg):
    logging.debug('Got argument %s' % arg)
    do_something()
    logging.info('This is a boring example')

logging模塊的日志級別與Robot Framework略有不同。其級別DEBUG和INFO直接映射到匹配的Robot Framework日志級別和警告，上面的所有內(nèi)容都映射到WARN。DEBUG級別以下的自定義級別映射到DEBUG，DEBUG和WARNING之間的一切都映射到INFO。

庫初始化期間的日志

庫還可以在測試庫導(dǎo)入和初始化期間進(jìn)行日志記錄。這些消息不像正常日志一樣顯示在日志文件中，而是被寫入syslog。這允許記錄庫初始化相關(guān)的所有有用的調(diào)試信息。使用WARN級別記錄的消息也可見于日志文件中的測試執(zhí)行錯(cuò)誤部分。

在導(dǎo)入和初始化過程中進(jìn)行登錄既可使用標(biāo)準(zhǔn)輸出流和錯(cuò)誤流，也可使用程序日志 ABI。這兩個(gè)都如下所示。

Java庫在初始化過程中借助標(biāo)準(zhǔn)輸出進(jìn)行記錄：

public class LoggingDuringInitialization {

    public LoggingDuringInitialization() {
        System.out.println("*INFO* Initializing library");
    }

    public void keyword() {
        // ...
    }
}

Python 庫在導(dǎo)入期間使用日志 API 進(jìn)行記錄：

from robot.api import logger

logger.debug("Importing library")

def keyword():
    # ...

注意
如果您在初始化過程中記錄某些信息，即在 Python init或 Java 構(gòu)造器中，則消息可能會根據(jù)測試庫范圍多次記錄。

在庫初始化期間將日志消息編寫到 syslog 的支持是Robot Framework 2.6 中的一個(gè)新功能。

返回值

關(guān)鍵字通信回核心框架的最后方式是返回從受測試的系統(tǒng)中檢索或通過其他方式生成的信息。返回的值可以分配給測試數(shù)據(jù)中的變量，然后用作其他關(guān)鍵字的輸入，甚至來自不同的測試庫。

返回值都是使用 的Python 和 Java 方法的return語句。通常一個(gè)值被分配到一個(gè)標(biāo)量變量，如下所示。此示例還說明，可以返回任何對象并使用擴(kuò)展變量語法訪問對象的屬性。

from mymodule import MyObject

def return_string():
    return "Hello, world!"

def return_object(name):
    return MyObject(name)

從關(guān)鍵字返回一個(gè)值

image.png

關(guān)鍵字也可以返回值，以便它們可以一次分配到多個(gè)標(biāo)量變量中，放入列表變量，或分配到標(biāo)量變量和列表變量中。所有這些用法都要求返回的值是 Python 列表或元組，或在 Java數(shù)組、列表或迭代器中。

def return_two_values():
    return 'first value', 'second value'

def return_multiple_values():
    return ['a', 'list', 'of', 'strings']

返回多個(gè)值

image.png

多線程通信

如果庫使用多線程，則通常只能從主線程與框架通信。例如，如果運(yùn)行的線程要報(bào)告失敗或記錄什么，則應(yīng)首先將信息傳遞到主線程，主線程可以使用本節(jié)中解釋的異?；蚱渌麢C(jī)制與框架進(jìn)行通信。

當(dāng)線程在后臺運(yùn)行，而其他關(guān)鍵字正在運(yùn)行時(shí)，這一點(diǎn)尤其重要。在這種情況下，與框架通信的結(jié)果未定義，在工作情況下可能導(dǎo)致崩潰或輸出文件損壞。如果關(guān)鍵字在后臺啟動某些內(nèi)容，則應(yīng)該有另一個(gè)關(guān)鍵字來檢查執(zhí)行線程的狀態(tài)，并相應(yīng)地報(bào)告收集的信息。

注意
使用編程記錄 API的非主線程記錄的消息從RobotFramework 2.6.2 開始被忽略。

4.1.5 分配測試庫

庫文檔

沒有關(guān)于它包含哪些關(guān)鍵字和這些關(guān)鍵字做什么的文檔的測試庫是相當(dāng)無用的。為了便于維護(hù)，我們強(qiáng)烈建議將庫文檔包含在源代碼中并由此生成?；旧希@意味著要使用Python的docstring和Java的Javadoc，如下示例。

class MyLibrary:
    """This is an example library with some documentation."""

    def keyword_with_short_documentation(self, argument):
        """This keyword has only a short documentation"""
        pass

    def keyword_with_longer_documentation(self):
        """First line of the documentation is here.

        Longer documentation continues here and it can contain
        multiple lines or paragraphs.
        """
        pass

/**
 *  This is an example library with some documentation.
 */
public class MyLibrary {

    /**
     * This keyword has only a short documentation
     */
    public void keywordWithShortDocumentation(String argument) {
    }

    /**
     * First line of the documentation is here.
     *
     * Longer documentation continues here and it can contain
     * multiple lines or paragraphs.
     */
    public void keywordWithLongerDocumentation() {
    }

}

Python 和 Java 都有創(chuàng)建上述文檔的 API 文檔的工具。但對于某些用戶來說，這些工具的輸出可能略帶技術(shù)性。另一種選擇是使用RobotFramework自己的文檔工具libdoc。此工具可以使用靜態(tài)庫 API（如上面的 API）創(chuàng)建來自 Python 和 Java 庫的庫文檔，但它也使用動態(tài)庫 API和混合庫 API處理庫。

關(guān)鍵字文檔的第一行用于特殊目的，并且應(yīng)包含關(guān)鍵字的簡短整體描述。它被libdoc用作**short documentation，例如作為工具提示，也顯示在測試日志中。但是，后者不使用靜態(tài) API 與 Java 庫合作，因?yàn)樗鼈兊奈臋n在編譯中丟失，在運(yùn)行時(shí)不可用。

注意
如果您想在 Python 庫的文檔中使用非 ASCII 字符，則必須使用 UTF-8 編碼，或?qū)⑽臋n字符串創(chuàng)建為 Unicode。

測試庫

任何重要的測試庫都需要經(jīng)過徹底測試以防止其中出現(xiàn)錯(cuò)誤。當(dāng)然，此測試應(yīng)實(shí)現(xiàn)自動化，以在更改庫時(shí)便于重新運(yùn)行測試。

Python 和 Java 都擁有出色的單元測試工具，它們非常適合測試庫。與用于其他測試相比，為此目的使用它們沒有重大區(qū)別。熟悉這些工具的開發(fā)人員不需要學(xué)習(xí)任何新內(nèi)容，不熟悉這些工具的開發(fā)人員無論如何都應(yīng)該學(xué)習(xí)它們。

也很容易使用RobotFramework本身測試庫，這樣可以為他們進(jìn)行實(shí)際的端到端驗(yàn)收測試。為此內(nèi)置庫中有很多有用的關(guān)鍵字。特別提及的是***Run Keyword And Expect Error*，這是有用的，為測試關(guān)鍵字報(bào)告正確的錯(cuò)誤。

是否使用單元級或驗(yàn)收級測試方法取決于上下文。如果需要模擬正在測試的實(shí)際系統(tǒng)，則在單元級別上通常更容易。另一方面，驗(yàn)收測試確保關(guān)鍵字運(yùn)行在RobotFramework。如果不能決定，也可以同時(shí)使用這兩種方法。

庫打包

庫實(shí)施、記錄和測試后，仍需要分發(fā)給用戶。使用由單個(gè)文件組成的簡單庫，要求用戶在某處復(fù)制該文件并相應(yīng)地設(shè)置庫搜索路徑通常就足夠了。應(yīng)打包更復(fù)雜的庫以便于安裝。

由于庫是正常的編程代碼，因此可以使用普通打包工具進(jìn)行封裝。在Python，選擇包括distutils，包括Python的標(biāo)準(zhǔn)庫，和較新的setuptools。這些工具的一個(gè)好處是將庫模塊安裝到自動在庫搜索路徑中的位置。

使用 Java 時(shí)，自然將庫打包到 JAR 存檔中。JAR 包在運(yùn)行測試之前必須放入庫搜索路徑中，但也可以很容易創(chuàng)建自動操作的啟動腳本。

棄用關(guān)鍵字

有時(shí)需要用新的關(guān)鍵字替換現(xiàn)有關(guān)鍵字或?qū)⑵渫耆珓h除。僅僅將更改告知用戶可能不夠，而且在運(yùn)行時(shí)間獲得警告效率更高。為了支持這一點(diǎn)，RobotFramework提供了標(biāo)記被棄用的關(guān)鍵字的能力*deprecated*。這使得從測試數(shù)據(jù)中查找舊關(guān)鍵字并刪除或替換它們變得更加容易。

關(guān)鍵字被棄用，以*DEPRECATED*開頭他們的文檔。執(zhí)行這些關(guān)鍵字時(shí)，包含其余簡短文檔的警告將同時(shí)寫入控制臺，并寫入日志文件中的單獨(dú)測試執(zhí)行錯(cuò)誤部分。例如，如果執(zhí)行以下關(guān)鍵字，日志文件中將顯示如下警告。

def example_keyword(argument):
    """*DEPRECATED* Use keyword `Other Keyword` instead.

    This keyword does something to given `argument` and returns the result.
    """
    return do_something(argument)

WARN    Keyword 'SomeLibrary.Example Keyword' is deprecated. Use keyword `Other Keyword` instead.

此棄用系統(tǒng)適用于大多數(shù)測試庫和用戶關(guān)鍵字。唯一例外是在Java測試庫中實(shí)現(xiàn)的關(guān)鍵字，該庫使用靜態(tài)庫接口，因?yàn)樗鼈兊奈臋n在運(yùn)行時(shí)間不可用。有了這些關(guān)鍵字，就可以使用用戶關(guān)鍵字作為裝飾器并棄用它們。

有一個(gè)計(jì)劃來實(shí)現(xiàn)一個(gè)工具，可以使用棄用信息自動替換廢棄的關(guān)鍵字。該工具很可能從文檔中獲取新關(guān)鍵字的名稱，以便搜索到引號 (```)中的單詞。因此，它會從前面的例子中找到Other Keyword。請注意，libdoc還使用相同的語法自動創(chuàng)建內(nèi)部鏈接。

4.1.6 動態(tài)庫API

動態(tài) API 在大多數(shù)方面與靜態(tài) API 相似。例如，報(bào)告關(guān)鍵字狀態(tài)、日志記錄和返回值的工作方式完全相同。最重要的是，與其他庫相比，導(dǎo)入動態(tài)庫和使用其關(guān)鍵字沒有區(qū)別，因此您甚至不需要知道庫使用什么 API。

靜態(tài)庫和動態(tài)庫之間的唯一區(qū)別是Robot Framework如何發(fā)現(xiàn)庫實(shí)現(xiàn)的關(guān)鍵字、它們具有哪些參數(shù)和文檔以及這些關(guān)鍵字的實(shí)際執(zhí)行方式。使用靜態(tài) API，所有這一切都是使用反射完成的（Java庫的文檔除外），但動態(tài)庫具有用于這些用途的特殊方法。

動態(tài) API 的優(yōu)點(diǎn)之一是在組織庫方面具有更大的靈活性。對于靜態(tài) API，所有關(guān)鍵字在類（或模塊）中，而對于動態(tài) API，可以將每個(gè)關(guān)鍵字作為單獨(dú)的類實(shí)現(xiàn)。此使用案例對于 Python 來說不是那么重要，因?yàn)樗膭討B(tài)功能和多重繼承已經(jīng)提供了足夠的靈活性，混合庫 API通常是一個(gè)更好的選擇。

動態(tài) API 的另一個(gè)主要用法是實(shí)現(xiàn)庫，以便它僅是其他計(jì)算機(jī)或其他 JVM 上實(shí)際庫的代理。這種代理庫可能非常小，并且由于關(guān)鍵字名稱是動態(tài)獲取的，因此當(dāng)將新關(guān)鍵字添加到實(shí)際庫時(shí)，無需更新代理。

本節(jié)解釋了動態(tài) API 如何在Robot Framework和動態(tài)庫之間工作。Robot Framework實(shí)際上如何實(shí)現(xiàn)這些庫并不重要（例如，如何將執(zhí)行run_keyword方法映射到正確的關(guān)鍵字），并且有許多不同的方法是可能的。但是，如果您使用 Java，您可能需要在實(shí)施自己的系統(tǒng)之前檢查JavalibCore。此可重復(fù)使用的工具集合支持創(chuàng)建關(guān)鍵字的幾種方法，而且它很可能已經(jīng)有一個(gè)機(jī)制來滿足您的需求。

獲取關(guān)鍵字名稱

動態(tài)庫使用get_keyword_names方法了解它們實(shí)施的關(guān)鍵字。該方法還具有在編寫 Java 時(shí)推薦的別名getKeywordNames。此方法不能攜帶任何參數(shù)，并且它必須返回字符串列表（在 Python 中）或包含庫實(shí)現(xiàn)的關(guān)鍵字名稱的字符串?dāng)?shù)組（在 Java 中）。

如果返回的關(guān)鍵字名稱包含幾個(gè)單詞，則可以用空格或下劃線或駝峰格式將它們分開返回。例如，['first keyword', 'second keyword'], ['first_keyword', 'second_keyword']和['firstKeyword', 'secondKeyword']都會導(dǎo)致關(guān)鍵字First Keyword和Second Keyword。

動態(tài)庫必須始終采用此方法。如果缺少它，或者如果出于某種原因調(diào)用失敗，則庫將被視為靜態(tài)庫。

執(zhí)行關(guān)鍵字

動態(tài)庫具有執(zhí)行關(guān)鍵字的特殊方法run_keyword（別名runKeyword）。當(dāng)測試數(shù)據(jù)中使用動態(tài)庫的關(guān)鍵字時(shí)，Robot Framework使用庫的run_keyword方法執(zhí)行。此方法需要兩個(gè)參數(shù)，第一個(gè)是包含要執(zhí)行的關(guān)鍵字的名稱的字符串，其格式與get_keyword_names返回的格式相同，第二個(gè)是提供給測試數(shù)據(jù)中關(guān)鍵字的參數(shù)列表（Java 中的對象數(shù)組）。

庫獲得關(guān)鍵字名稱和參數(shù)后，可以自由執(zhí)行關(guān)鍵字，但必須使用與靜態(tài)庫的框架相同的機(jī)制進(jìn)行通信。這意味著使用異常報(bào)告關(guān)鍵字狀態(tài)，通過編寫到標(biāo)準(zhǔn)輸出進(jìn)行記錄，并在run_keyword中使用返回語句返回某些內(nèi)容。

每個(gè)動態(tài)庫都必須具有get_keyword_names和run_keyword方法。動態(tài) API 中的其余方法是可選的，因此下面是一個(gè)可用動態(tài)庫。

class DynamicExample:

    def get_keyword_names(self):
        return ['first keyword', 'second keyword']

    def run_keyword(self, name, args):
        print "Running keyword %s with arguments %s" % (name, args)

獲取關(guān)鍵字參數(shù)

如果動態(tài)庫僅實(shí)現(xiàn)get_keyword_names和run_keyword方法，則Robot Framework沒有任何有關(guān)已實(shí)施關(guān)鍵字所需的參數(shù)的信息。例如，上述示例中的第一個(gè)關(guān)鍵字和第二個(gè)關(guān)鍵字都可用于任意數(shù)量的參數(shù)。這是有問題的，因?yàn)榇蠖鄶?shù)真正的關(guān)鍵字期望一定數(shù)量的關(guān)鍵字，在這種情況下，他們需要檢查參數(shù)計(jì)數(shù)本身。

動態(tài)庫可以使用get_keyword_arguments（別名獲取關(guān)鍵字）方法告訴Robot Framework它實(shí)現(xiàn)的關(guān)鍵字實(shí)際期望的參數(shù)。此方法以關(guān)鍵字的名稱為參數(shù)，并返回包含該關(guān)鍵字所接受的參數(shù)的字符串列表（Java 中的字符串陣列）。

與靜態(tài)關(guān)鍵字類似，動態(tài)關(guān)鍵字可能需要任意數(shù)量的參數(shù)、具有默認(rèn)值和接受可變數(shù)的參數(shù)。下表解釋了如何表示所有這些不同情況的語法。請注意，示例使用 Python 字符串列表，但 Java 開發(fā)人員應(yīng)該能夠?qū)⑵浞g為字符串陣列。

當(dāng)使用get_keyword_arguments時(shí)，Robot Framework會自動計(jì)算關(guān)鍵字需要多少參數(shù)。如果使用關(guān)鍵字的參數(shù)數(shù)為無效，則會出現(xiàn)錯(cuò)誤，并且甚至沒有調(diào)用run_keyword。上表的最后一列顯示了從所示示例中計(jì)算的最低和最大參數(shù)計(jì)數(shù)。

執(zhí)行測試時(shí)，實(shí)際參數(shù)名稱并不重要，因?yàn)镽obot Framework只關(guān)注參數(shù)計(jì)數(shù)。另一方面，如果libdoc工具用于記錄庫，則文檔中顯示參數(shù)，在這種情況下，它們需要有有意義的名稱。

獲取關(guān)鍵字文檔

動態(tài)圖書館可以實(shí)施的最后一種特殊方法是get_keyword_documentation（別名獲取關(guān)鍵字文件）。它將關(guān)鍵字名稱作為參數(shù)，并且，正如方法名稱所暗示的那樣，將其文檔返回為字符串。

返回的文檔同樣用作使用 Python 實(shí)現(xiàn)的靜態(tài)庫的關(guān)鍵字文檔字符串。主要用途是將關(guān)鍵字的文檔放入由libdoc生成的庫文檔中。此外，文檔的第一行（直到第一行\(zhòng)n）顯示在測試日志中。

獲取總庫文檔

get_keyword_documentation方法也可用于指定整體庫文檔。執(zhí)行測試時(shí)不使用此文檔，但它可以使libdoc生成的文檔變得更好。

動態(tài)圖書館可以同時(shí)提供與使用圖書館相關(guān)的一般圖書館文檔和文檔。前者是通過調(diào)用具有特殊價(jià)值intro的get_keyword_documentation獲得，后者是利用價(jià)值init。文檔的呈現(xiàn)方式在實(shí)踐中最好地通過libdoc進(jìn)行測試。

基于 Python 的動態(tài)庫還可以將代碼中的一般庫文檔直接指定為庫類的文檔或其init方法。如果非空文檔直接來自代碼和get_keyword_documentation方法，則后者具有更高的優(yōu)先級。

注意

獲取一般庫文檔支持Robot Framework 2.6.2 和較新的文檔。

總結(jié)

動態(tài) API 中的所有特殊方法都列在下表中。方法名稱列在下劃線格式中，但其駱駝箱別名的工作方式完全相同。

動態(tài) API 中的所有特殊方法

可以按照以下方式在 Java 中編寫正式的界面規(guī)范。但是，請記住，庫不需要實(shí)施任何明確的界面，因?yàn)镽obot Framework直接檢查與反射，如果庫有所需的get_keyword_names和run_keyword方法。此外，get_keyword_arguments和get_keyword_documentation是完全可選的。

public interface RobotFrameworkDynamicAPI {

    String[] getKeywordNames();

    Object runKeyword(String name, Object[] arguments);

    String[] getKeywordArguments(String name);

    String getKeywordDocumentation(String name);

}

使用動態(tài)API的一個(gè)很好的例子是Robot Framework自己的遠(yuǎn)程庫。

4.1.7 混合庫API

獲取關(guān)鍵字名稱

執(zhí)行關(guān)鍵字

獲取關(guān)鍵字參數(shù)和文檔

總結(jié)

4.1.8 使用RobotFramework的內(nèi)置模塊

可用API

使用Builtln庫

4.1.9 擴(kuò)展存在的測試庫

修改初始源碼

使用繼承

直接使用其他庫

從Robot Framework獲取有效的庫實(shí)例

使用動態(tài)或混合API的庫

4.2 遠(yuǎn)程庫接口

4.3 使用監(jiān)聽接口

4.4 擴(kuò)展Robot Framework Jar