@aj-shadow/actorjs-documentation-text 0.0.0-aj-beta.221

package/Documentation/abstractions/Document-global-test-data.txt

@@ -0,0 +1,251 @@
+[[NOTE={"guid":"ff553d94-1ee1-4dc2-8a38-c41a57118259"}]]
+# **Test Data Abstraction**
+## **Description**
+All kinds of data that the [[REF=, ABS_Actor]]s might need to execute is called [[REF=, ABS_Test_Data]], except data needed for verification which is called [[REF=, ABS_Verification_Data]] and MIME formatted data which is called [[REF=, ABS_Content]]. To be able to reuse an [[REF=, ABS_Actor]] in many [[REF=, ABS_Test_Case]]s, the [[REF=, ABS_Test_Data]] must be separated from the implementation. [[REF=, ABS_Test_Data]] required by a [[REF=, ABS_Test_Case]] is not explicitly determined by the [[REF=, ABS_Test_Case]]; the [[REF=, ABS_Actor]]s decide what [[REF=, ABS_Test_Data]] they need. 
+
+See how to use it in the [[REF=, API_Actor_Test_Data]].
+
+[[ANCHOR={"id":"test-data-processing","visible":true}]]
+[[NOTE={"guid":"d119bea5-2635-432e-a382-ac67a08656fc"}]]
+## **Test Data processing**
+Generation of the required [[REF=, ABS_Test_Data]] involves very complex processing of the [[REF=, ABS_Test_Data]].
+```node
+Config(nodeWidth: 100, nodeHeight: 35, nodeWidthBetween: 25, nodeHeightBetween: 25, widthBias: 30, heightBias: 30, border: true, backgroundColor: default)
+
+Nodes[API call, Table Lookup, Formatting, Dictionary, Result]
+Nodes[, Default Value, , JSON.parse || cast]
+
+
+API call => Table Lookup[, , , false]: 
+Table Lookup => Default Value[, , , false]: 
+Table Lookup => Formatting[, , , false]: 
+Default Value => Formatting[, , , false]: 
+Formatting => Dictionary[, , , false]: 
+Formatting => JSON.parse || cast[, , left, false]: 
+Dictionary => Result[, , , false]: 
+JSON.parse || cast => Result[, , , false]: 
+```
+[[ANCHOR={"id":"test-data-processing-steps","visible":true}]]
+[[NOTE={"guid":"3c03c953-a74d-4f55-981e-da0bd3502536"}]]
+### **Test Data processing steps:**
+1) An [[REF=, ABS_Actor]] calls a method in the [[REF=, API_Actor_Test_Data]].
+2) [[REF=, ABS_Test_Data_Input]] is found:
+    * Through a [[REF=, ABS_Test_Data_Table_Lookup]] in one of the [[REF=, ABS_Test_Data]] tables, or
+    * As [[REF=, ABS_Test_Data_Default_Value]] provided in the call to the [[REF=, API_Actor_Test_Data]]
+3) If ***value*** contains a ***key*** to other [[REF=, ABS_Test_Data]], [[REF=Formatting, ABS_Test_Data_Formatting]] is performed; that is, ***value*** = [[IE="Hello **$[**name**]**, how do you do?"]] contains the ***key*** name.
+4) Once [[REF=, ABS_Test_Data_Formatting]] is complete, one of the following [[REF=, ABS_Test_Data_Transformations]] can be performed in these cases:
+    * If the [[REF=, ABS_Actor]] provides a [[REF=, ABS_Test_Data_Dictionary]], then this [[REF=, ABS_Test_Data_Dictionary]] is used, or
+    * If the type is incorrect, a JSON.parse or cast will be performed
+5) The [[REF=, ABS_Test_Data_Resulting]] is returned or an exception is thrown.
+
+[[ANCHOR={"id":"test-data-flowchart","visible":true}]]
+```flow
+Title: Test Data Processing Flowchart
+Blocks[, Start(start:getTestData...::)]
+Blocks[]
+Blocks[, getValue(action:get table value with key::)]
+Blocks[]
+Blocks[, dValue(decision:table value found ?::), ]
+Blocks[]
+Blocks[yesValue(action:format value::), , , noValue(action:get default::)]
+Blocks[forAllKeys(action:for all found keys::)]
+Blocks[callTestData...(action:call getTestData::), , , dDefault(decision:default found ?::), ]
+Blocks[]
+Blocks[, , dDefaultType(decision:typeof default ?::), , noDefault(end:exception:#e74c3c:)]
+Blocks[]
+Blocks[, , , function(action:function returns value::)]
+Blocks[, value(end:value::)]
+Blocks[]
+Blocks[, dDictionary(decision:dictionary found ?::)]
+Blocks[]
+Blocks[yesDictionary(action:lookup value::), , nodDictionary(decision:correct type ?::)]
+Blocks[]
+Blocks[, , , noType(action:JSON.parse || cast::)]
+Blocks[notFound(end:exception:#e74c3c:), yesType(end:value: #2ecc71 :), , , parseCastError(end:exception:#e74c3c:)]
+
+Start => getValue[unknown]: 
+getValue => dValue[unknown]: 
+dValue => yesValue[unknown]: yes
+dValue => noValue[unknown]: no
+noValue => dDefault[unknown]: 
+yesValue => [unknown]: yesValue => dDefaultType
+dDefault => dDefaultType[unknown]: yes
+dDefault => noDefault[unknown]: no
+dDefaultType => value[unknown]: string
+dDefaultType => function[unknown]: function
+yesValue => value[unknown]: 
+function => value[unknown]: 
+value => dDictionary[unknown]: 
+dDictionary => yesDictionary[unknown]: yes
+dDictionary => nodDictionary[unknown]: no
+yesDictionary => yesType[unknown]: found
+yesDictionary => notFound[unknown]: not found
+nodDictionary => yesType[unknown]: yes
+nodDictionary => noType[unknown]: no
+noType => yesType[unknown]: ok
+noType => parseCastError[unknown]: failure
+```
+[[ANCHOR={"id":"test-data-input","visible":true}]]
+[[NOTE={"guid":"02da482d-c148-456a-8948-d2282f59117d"}]]
+## **Test Data input**
+[[ANCHOR={"id":"test-data-format","visible":true}]]
+[[NOTE={"guid":"0f48e652-1da5-49de-bcbb-20ad64394db6"}]]
+### **Test Data format**
+The general format of [[REF=, ABS_Test_Data]] is:
+1) **key**: name of the [[REF=, ABS_Test_Data]].
+2) **value**: value of the [[REF=, ABS_Test_Data]]. The string ***value*** must be in a format so a cast or a JSON.parse can transform it into the requested type.
+3) **description**: optional text added to describe the purpose of [[REF=, ABS_Test_Data]].
+
+[[ANCHOR={"id":"test-data-types","visible":true}]]
+[[NOTE={"guid":"47c85525-9dbc-43bf-a3e9-71dc0887a388"}]]
+### **Test Data types**
+* [[REF=, MDN_string]], a string, [[IE='this is a string']].
+* [[REF=, MDN_strings]], a string array, [[IE=["This is the first string", "This is the second string"] ]].
+* [[REF=, MDN_arraystrings]], an array of string arrays, [ [IE=[["This", "is", "the", "first", "array"], ["The", "second", "array"] ] ]]
+* [[REF=, MDN_number]], a number, [[IE=1, -39, 1.2222]].
+* [[REF=, MDN_numbers]], a number array, [[IE=[1, 2] ]].
+* [[REF=, MDN_arraynumbers]], an array of number arrays, [[IE=[ [11, 12, 13, 14], [21, 22, 23, 24] ] ]]
+* [[REF=, MDN_boolean]], a boolean, [[IE=true || false]] else [[IE=undefined]].
+* [[REF=, MDN_booleans]], a boolean array, [[IE=[true, false, false, true, undefined] ]]
+* [[REF=, MDN_arraybooleans]], an array of boolean arrays, [[IE=[ [true, false, false, true, undefined], [true, true, true, true] ] ]]
+* [[REF=, MDN_object]], an object, [[IE={name: 'hello', age: 32}]].
+ 
+More [[REF=, ABS_Test_Data]] types will be added in the future, but for now developers of [[REF=, ABS_Actor]]s can read in data as strings and then *cast* them as needed.
+
+[[ANCHOR={"id":"test-data-source","visible":true}]]
+[[NOTE={"guid":"b816d6aa-3163-4b70-a426-a0507f6271ef"}]]
+### **Test Data source**
+[[REF=, ABS_Test_Data]] can be provided in several ways. For [[REF=, ABS_Test_Case]]s and [[REF=, ABS_Test_Data]] to be maintainable, it is important to store the [[REF=, ABS_Test_Data]] in the correct layer according to its intended use: 
+
+1) [[REF=, ABS_Local_Test_Data]] layer: [[REF=, ABS_Test_Data]] will be used only by [[REF=, ABS_Actor]]s in the [[REF=, ABS_Test_Case]].
+
+2) [[REF=, ABS_Global_Test_Data]] layer: [[REF=, ABS_Test_Data]] will be global and used by all kinds of [[REF=, ABS_Test_Case]]s.
+
+3) [[REF=, ABS_Static_Test_Data]] layer: [[REF=, ABS_Test_Data]] will be static so it can be either hard-coded in the [[REF=, ABS_Actor]] or provided by the [[REF=, API_Actor_Test_Data]].
+
+`IMPORTANT! DO NOT:`
+1) Store [[REF=, ABS_Local_Test_Data]] as [[REF=, ABS_Global_Test_Data]]. Updating this [[REF=, ABS_Test_Data]] will affect all [[REF=, ABS_Actor]]s using this data.
+ 
+2) Store [[REF=, ABS_Global_Test_Data]] as [[REF=, ABS_Local_Test_Data]]. Doing so will create significant maintenance problems! Any single update will require updates in all [[REF=, ABS_Test_Case]]s using this [[REF=, ABS_Test_Data]].
+3) Use [[REF=, ABS_Static_Test_Data]] when changes are needed for different [[REF=, ABS_Test_Case]]s.
+
+#### **Tools for handling Test Data**
+* [[REF=, ABS_Local_Test_Data]] is handled in the [[REF=, TOOL_Test_Case_Definition]].
+
+* [[REF=, ABS_Global_Test_Data]] is handled in the [[REF=, TOOL_Global_Test_Data]].
+
+* [[REF=, ABS_Static_Test_Data]] is handled in the implementation of an [[REF=, ABS_Actor]] in the [[REF=, TOOL_Actor_Editor]].
+
+[[ANCHOR={"id":"test-data-table-lookup","visible":true}]]
+[[NOTE={"guid":"3def3e11-9c95-45ad-84a5-a0bee2947a19"}]]
+### **Table Lookup**
+When an [[REF=, ABS_Actor]] requires [[REF=, ABS_Test_Data]], the [[REF=, API_Actor_Test_Data]] searches for [[REF=, ABS_Test_Data]] layer by layer in the following order: Local, Global, Static. The first occurrence found will be the returned [[REF=, ABS_Test_Data]]. This makes the [[REF=, ABS_Test_Data]] overrideable; for example, if [[REF=, ABS_Test_Data]] is set in the global tables, this [[REF=, ABS_Test_Data]] will be used as long as no [[REF=, ABS_Test_Data]] with the same **key** is found in the local tables. 
+
+##### **Test Data layer search order:**
+* [[REF=, ABS_Test_Data_Runtime_Layer]]
+* [[REF=, ABS_Test_Data_Local_Layer]]
+* [[REF=, ABS_Test_Data_Global_Layer]]
+* [[REF=, ABS_Test_Data_Static_Layer]]
+
+[[ANCHOR={"id":"runtime-test-data-layer","visible":true}]]
+[[NOTE={"guid":"afaa3196-2376-4cbe-87b2-f06d65e9138d"}]]
+#### **Runtime Test Data layer** `Not Implemented`
+The layer contains data generated in runtime in the [[REF=, ABS_Actor]]s. The [[REF=, ABS_Actor]]s can proved an array with [[REF=, ABS_Test_Data]] to the [[REF=, API_Actor_Test_Data]]. The format is an array where every array element contains an array defining ***key*** and ***value***.
+##### **Example**
+```javascript
+
+const myRuntimeTestData = [['name', 'john'], [age, 31]];
+
+```
+
+[[ANCHOR={"id":"local-test-data-layer","visible":true}]]
+[[NOTE={"guid":"46b20c60-3a5c-4376-ab6e-452fe1857e0b"}]]
+#### **Local Test Data layer**
+The [[REF=, ABS_Local_Test_Data]] layer contains the following sub-layers:
+* Actor Test Data layer
+* Test Data Iteration layer
+* Test Case Test Data layer
+
+[[ANCHOR={"id":"global-test-data-layer","visible":true}]]
+[[NOTE={"guid":"0c105321-c172-46b0-b806-06bf966bb32d"}]]
+
+#### **Global Test Data layer**
+The [[REF=, ABS_Global_Test_Data]] layer contains the following sub-layers:
+* [[REF=, TOOL_Global_Test_Data_General]]
+  * [[REF=, TOOL_Global_Test_Data_General_Local]] – [[REF=, ABS_Repo_Local]]
+  * [[REF=, TOOL_Global_Test_Data_General_Global]] – [[REF=, ABS_Repo_Global]]
+* [[REF=, TOOL_Global_Test_Data_System]]
+  * [[REF=, TOOL_Global_Test_Data_System_Local]]  – [[REF=, ABS_Repo_Local]]
+  * [[REF=, TOOL_Global_Test_Data_System_Global]]  – [[REF=, ABS_Repo_Global]]
+* [[REF=, TOOL_Global_Test_Data_Log]]
+  * [[REF=, TOOL_Global_Test_Data_Log_Local]] – [[REF=, ABS_Repo_Local]]
+  * [[REF=, TOOL_Global_Test_Data_Log_Global]] – [[REF=, ABS_Repo_Global]]
+* [[REF=, TOOL_Global_Test_Data_Environment]]
+  * [[REF=, TOOL_Global_Test_Data_Environment_Local]] – [[REF=, ABS_Repo_Local]]
+  * [[REF=, TOOL_Global_Test_Data_Environment_Global]]  – [[REF=, ABS_Repo_Global]]
+  * [[REF=, TOOL_Global_Test_Data_Environment_Static]]  – static
+
+[[ANCHOR={"id":"test-data-default-value","visible":true}]]
+[[NOTE={"guid":"c8fe90ab-115d-4260-a077-cc76e992f0aa"}]]
+### **Default Value**
+[[ANCHOR={"id":"static-test-data-layer","visible":true}]]
+[[NOTE={"guid":"a267256c-d8c4-47ee-ac41-4a2099a898c4"}]]
+#### **Static Test Data layer**
+The [[REF=, ABS_Static_Test_Data]] layer contains hard-coded default values from the implementation of [[REF=, ABS_Actor]]s or values provided by the [[REF=, API_Actor_Test_Data]]:
+* [[REF=, TOOL_Global_Test_Data_Environment_Static]]  – static
+
+[[ANCHOR={"id":"test-data-formatting","visible":true}]]
+[[NOTE={"guid":"9b93a17b-cb3a-4adb-9b41-03f07ac87a6b"}]]
+## **Test Data formatting**
+[[REF=, ABS_Test_Data]] can contain references to other [[REF=, ABS_Test_Data]]. [[REF=, ABS_Test_Data]] is constructed by a key/value pair, and if the value contains references to other [[REF=, ABS_Test_Data]], formatting will take place. [[REF=, ABS_Test_Data]] can contain references to [[REF=, ABS_Test_Data]], which in turn contains references to [[REF=, ABS_Test_Data]], which in turn contains ...and so on. However, circular references are not allowed.
+
+The format of being be able to link to another [[REF=, ABS_Test_Data]] is similar to JavaScript's *template string*, but square brackets are used instead of regular brackets.
+
+**Example**
+{**key**: 'name', **value**: 'Bill'} [[IE=No formatting: "Bill"]].
+{**sentence**: 'name', **value**: 'Hello $[name], How do you do?'} [[IE=Formatting: "Hello Bill, How do you do?"]].
+
+**$[**name**]** is now replaced by the value of the [[REF=, ABS_Test_Data]] with the value identified by the **key** "name", which in this example is Bill.
+
+[[ANCHOR={"id":"test-data-transformations","visible":true}]]
+[[NOTE={"guid":"07177719-e39e-4e9b-ab64-7bba1af347bd"}]]
+## **Transformations**
+If a [[REF=, ABS_Test_Data_Dictionary]] is provided, this [[REF=, ABS_Test_Data_Dictionary]] will be used to transform the [[REF=, ABS_Test_Data]]. Otherwise, the [[REF=, API_Actor_Test_Data]] could cast to the requested type, or perform a JSON.parse to form arrays or objects.
+[[ANCHOR={"id":"test-data-dictionary","visible":true}]]
+[[NOTE={"guid":"bfb63d24-65f5-49a5-9e56-acb2f5717342"}]]
+### **Test Data Dictionary**
+When a [[REF=, ABS_Test_Data_Dictionary]] is provided, [[REF=Reflection, MDN_Reflect]] is used to find a member with the name equal to ***value*** of the [[REF=, ABS_Test_Data]]. When a member is found, ***value*** is set to that member's value. This pattern enables the implementation of an [[REF=, ABS_Actor]] to avoid long **if** or **switch** statements.
+
+**Example**
+```javascript
+
+  const e = this.getTestDataString('demoKeyObject', 'AP', {
+    ASAP: 'As soon as Possible',
+    FYI: 'For your information',
+    AP: 'Action point'
+  });
+}
+```
+* **Value** of [[REF=, ABS_Test_Data]] demoKeyObject is 'ASAP': the resulting [[REF=, ABS_Test_Data]] will be [[IE=As soon as Possible]]
+* **Value** of [[REF=, ABS_Test_Data]] demoKeyObject is 'FYI: the resulting [[REF=, ABS_Test_Data]] will be [[IE=For your information]]
+* **Value** of [[REF=, ABS_Test_Data]] demoKeyObject is 'AP: the resulting [[REF=, ABS_Test_Data]] will be [[IE=Action point]]
+* **Value** of [[REF=, ABS_Test_Data]] demoKeyObject is not found: the resulting [[REF=, ABS_Test_Data]] will be [[IE=Action point]], because the [[REF=, ABS_Test_Data_Default_Value]] **value** is 'AP'
+[[ANCHOR={"id":"test-data-resulting-test-data","visible":true}]]
+[[NOTE={"guid":"cac3f4f5-4961-4994-92d2-da110867b46d"}]]
+## **Resulting Test Data**
+If any [[REF=, ABS_Test_Data_Resulting]] is available, this [[REF=, ABS_Test_Data_Resulting]] will be returned from the [[REF=, API_Actor_Test_Data]] method.
+
+If no [[REF=, ABS_Test_Data_Resulting]] is available, an exception is thrown and the [[REF=, ABS_Test_Case]] will end with result: Error. The error log will describe what went wrong.
+
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>
+<br>

package/Documentation/abstractions/Document-global-test-suite.txt

@@ -0,0 +1,37 @@
+# **Test Suite Abstraction**
+
+## **Description**
+
+
+[[ANCHOR={"id":"7f833cd6-1770-45b8-96b9-32423f91fbda","visible":true}]]
+[[NOTE={"guid":"4bcabc8f-99ca-487d-9c1c-a0d0d0a788e2"}]]
+### **Creating a Test Suite**
+[[ANCHOR={"id":"5c3f4148-fb0d-42fc-9984-0d86e3f51848","visible":true}]]
+[[NOTE={"guid":"87a9842a-16a2-4eaa-99d4-29ea7a3c50f8"}]]
+#### **Table**
+To Create a [[REF=, ABS_Test_Suite]] it is just to create a table with the [[REF=, ABS_Test_Case]]s and [[REF=, ABS_Test_Suite]]s to be executed.
+```ts
+|TestSuiteAbstraction                                               |
+|name                                          |execution|iterations|
+|tc.Actor.Demo.DemoMobileBrowsingLogin         |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingGetImage      |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingRightsGetImage|         |          |
+|tc.Actor.Demo.DemoMobileBrowsingImageBmp      |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingImageGif      |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingImageJpg      |         |          |
+```
+[[ANCHOR={"id":"322e8788-50aa-4d9b-889e-96a0ba2d70cf","visible":true}]]
+[[NOTE={"guid":"d6466c03-7924-44b8-8500-9ddbb19ffc3c"}]]
+#### **Markup**
+Editing the tables will be done in a markup text format. This means that they will be easy to store in a repo and it will be easy to merge them.
+```escape
+
+|TestSuiteAbstraction                                               |
+|name                                          |execution|iterations|
+|tc.Actor.Demo.DemoMobileBrowsingLogin         |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingGetImage      |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingRightsGetImage|         |          |
+|tc.Actor.Demo.DemoMobileBrowsingImageBmp      |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingImageGif      |         |          |
+|tc.Actor.Demo.DemoMobileBrowsingImageJpg      |         |          |
+```

package/Documentation/abstractions/Document-global-verification-data.txt

@@ -0,0 +1,103 @@
+# **Verification Data Abstraction**
+## **Description**
+All kinds of data that the [[REF=, ABS_Actor]]s might need to perform verification is called [[REF=, ABS_Verification_Data]]. To be able to reuse an [[REF=, ABS_Actor]] in many [[REF=, ABS_Test_Case]]s, the [[REF=, ABS_Verification_Data]] must be separated from the implementation. [[REF=, ABS_Verification_Data]] required by a [[REF=, ABS_Test_Case]] is not explicitly determined by the [[REF=, ABS_Test_Case]]; the [[REF=, ABS_Actor]]s decide what [[REF=, ABS_Verification_Data]] they need.
+
+[[REF=, ABS_Verification_Data]] is separated from [[REF=, ABS_Test_Data]] to simplify the management of data. [[REF=, ABS_Verification_Data]] can use [[REF=, ABS_Test_Data]] and [[REF=, ABS_Test_Data_Formatting]].
+
+## **Types of Verifications**
+There are three types of verification:
+* [[REF=, ABS_Verification_Data_Value]]
+* [[REF=, ABS_Verification_Data_Optional]]
+* [[REF=, ABS_Verification_Data_Mandatory]]
+
+[[ANCHOR={"id":"verify-value","visible":true}]]
+[[NOTE={"guid":"fa901d92-3e22-4313-9283-5be1093356f4"}]]
+### **Verify Value**
+Verify Value is hard-coded verification in the [[REF=, ABS_Actor]]. This verification is used when the [[REF=, ABS_Actor]] always expects the same value.
+#### **Example** 
+When getting an image over http we know that we always expect a 200 Ok as response to succeed the [[REF=, ABS_Test_Case]].
+```seq
+Config(nodeWidth: 150, nodeMessageHeight: 17, nodeEventHeight: 10, nodeCommentHeight: 26, widthBias: 30, heightBias: 30, lineNumbers: false, border: true, backgroundColor: default)
+
+Nodes[orig, SUT, term]
+orig => SUT[http]: GET /image
+SUT => term[http]: GET /image
+term => SUT[http]: 200 Ok
+SUT => orig[http]: 200 Ok
+```
+```javascript
+
+this.httpConnection.send(new HttpMsgGetRequest(this.requistUri));
+    
+const response = this.httpConnection.receive();
+VERIFY_VALUE(HttpApi.StatusCode.OK, response.statusCode, ' HTTP response line status code:');
+
+```
+
+[[ANCHOR={"id":"verify-optional","visible":true}]]
+[[NOTE={"guid":"391155b6-6eb3-420c-ac0c-f66bc1d65382"}]]
+### **Verify Optional**
+Verify Optional is verification in the [[REF=, ABS_Actor]] where the developer can choose in  the [[REF=, ABS_Test_Case]] to do the verification or not. If the expected value is not provided in the [[REF=, ABS_Test_Case]] the verification will not be done and it will succeed.
+
+#### **Example** 
+When getting an image over http the developer of the [[REF=, ABS_Actor]] can let developer of the [[REF=, ABS_Actor]] to choose to verify the response or not in the [[REF=, ABS_Test_Case]].
+```seq
+Config(nodeWidth: 150, nodeMessageHeight: 17, nodeEventHeight: 10, nodeCommentHeight: 26, widthBias: 30, heightBias: 30, lineNumbers: false, border: true, backgroundColor: default)
+
+Nodes[orig, SUT, term]
+orig => SUT[http]: GET /image
+SUT => term[http]: GET /image
+term => SUT[http]: 200 Ok
+SUT => orig[http]: 200 Ok
+```
+```javascript
+
+this.httpConnection.send(new HttpMsgGetRequest(this.requistUri));
+    
+const response = this.httpConnection.receive();
+VERIFY_VALUE(HttpApi.StatusCode.OK, response.statusCode, ' HTTP response line status code:');
+VERIFY_CONTENT_OPTIONAL('content-name', response.getHeaderNumber(HttpApi.Header.CONTENT_LENGTH), response.getBody());
+
+```
+Only if the developer of the [[REF=, ABS_Test_Case]] provides the value the verification will take place.
+```tc
+|TestDataTestCase                   |
+|key         |value     |description|
+|content-name|pettersson|           |
+|            |          |           |
+```
+
+[[ANCHOR={"id":"verify-mandatory","visible":true}]]
+[[NOTE={"guid":"4feef5af-d2c8-445d-88fd-877869004e61"}]]
+### **Verify Mandatory**
+Verify Mandatory is verification in the [[REF=, ABS_Actor]] where the developer must provide the expected value in the [[REF=, ABS_Test_Case]]. If the expected value is not provided in the [[REF=, ABS_Test_Case]], the verification will fail.
+
+#### **Example** 
+When getting an image over http the developer of the [[REF=, ABS_Actor]] can force the developer of the [[REF=, ABS_Test_Case]] to verify the response in the [[REF=, ABS_Test_Case]].
+```seq
+Config(nodeWidth: 150, nodeMessageHeight: 17, nodeEventHeight: 10, nodeCommentHeight: 26, widthBias: 30, heightBias: 30, lineNumbers: false, border: true, backgroundColor: default)
+
+Nodes[orig, SUT, term]
+orig => SUT[http]: GET /image
+SUT => term[http]: GET /image
+term => SUT[http]: 200 Ok
+SUT => orig[http]: 200 Ok
+```
+```javascript
+
+this.httpConnection.send(new HttpMsgGetRequest(this.requistUri));
+    
+const response = this.httpConnection.receive();
+VERIFY_VALUE(HttpApi.StatusCode.OK, response.statusCode, ' HTTP response line status code:');
+VERIFY_CONTENT_MANDATORY('content-name', response.getHeaderNumber(HttpApi.Header.CONTENT_LENGTH), response.getBody());
+
+```
+
+The developer of the [[REF=, ABS_Test_Case]] must provide the value for the verification else it will fail.
+```tc
+|TestDataTestCase                   |
+|key         |value     |description|
+|content-name|pettersson|           |
+|            |          |           |
+```
+

package/Documentation/abstractions/actor/Document-global-actor-condition.txt

@@ -0,0 +1,74 @@
+# **Actor Condition**
+
+## **Description**
+The [[REF=, ABS_Actor_Condition]] does have client capabilities. It means that it can use a [[REF=, ABS_Stack_Client_Connection]]s to setup connections and communicate with servers.
+The [[REF=, ABS_Actor_Condition]] can be used in the [[REF=, ABS_Test_Case_Phase_Precondition]] and the [[REF=, ABS_Test_Case_Phase_Postcondition]]. The [[REF=, ABS_Actor_Condition]] is special constructed for restoring configuration at the [[REF=, ABS_System_Under_Test]]. If it succeeded in the  [[REF=, ABS_Test_Case_Phase_Precondition]] it will also be executed in the [[REF=, ABS_Test_Case_Phase_Postcondition]] even if there is an error or failure!
+
+## **States**
+The [[REF=, ABS_Actor_Originating]] supports the following [[REF=, ABS_Actor_State_Execution]]:
+* ***data**
+* ***initClientPre**
+* ***runPre**
+* ***exitPre**
+* ***initClientPost**
+* ***runPost**
+* ***exitPost**
+
+```state
+Title: ActorCondition
+Config(width: 400, height: 200, widthBias: 25, heightBias: 25)
+
+States[data, initClientPre, runPre]
+States[, , exitPre]
+States[, , initClientPost, runPost]
+States[, done, , exitPost]
+
+data -> initClientPre[success]: success
+data -> done[failure]: error, failure, interrupt
+initClientPre -> runPre[success]: success
+initClientPre -> done[failure]: error, failure, interrupt
+runPre -> exitPre[normal]: always
+exitPre -> initClientPost[normal]: always
+initClientPost -> runPost[success]: success
+initClientPost -> done[failure]: error, failure
+runPost -> exitPost[normal]: always
+exitPost -> done[normal]: always
+```
+
+## **Example 1 - Actor Condition Wizard**
+Here is the code produced by the [[REF=, ABS_Actor_Condition]] Wizard.
+```javascript
+
+const ActorApi = require('actor-api');
+
+
+class NotImplementedCond extends ActorApi.ActorCondition {
+  constructor() {
+    super();
+  }
+  
+  *data() {
+  }
+  
+  *initClientPre() {
+  }
+  
+  *runPre() {
+  }
+  
+  *exitPre() {
+  }
+  
+  *initClientPost() {
+  }
+  
+  *runPost() {
+  }
+  
+  *exitPost() {
+  }
+}
+
+module.exports = NotImplementedCond;
+
+```

package/Documentation/abstractions/actor/Document-global-actor-local.txt

@@ -0,0 +1,44 @@
+# **Actor Local**
+
+## **Description**
+The [[REF=, ABS_Actor_Local]] does not have any client or server capabilities. It is usually used to verify or calculate Data. The [[REF=, ABS_Actor_Local]] can be used in all [[REF=, ABS_Test_Case_Phases]].
+
+## **States**
+The [[REF=, ABS_Actor_Local]] supports the following [[REF=, ABS_Actor_State_Execution]]:
+* ***data**
+* ***run**
+
+```state
+Title: ActorLocal
+Config(width: 400, height: 200, widthBias: 25, heightBias: 25)
+
+States[data, run]
+States[, done]
+
+data -> run[success]: success
+data -> done[failure]: error, failure, interrupt
+run -> done[normal]: always
+```
+
+## **Example 1 - Actor Local Wizard**
+Here is the code produced by the [[REF=, ABS_Actor_Local]] Wizard.
+```javascript
+
+const ActorApi = require('actor-api');
+
+
+class NotImplementedLocal extends ActorApi.ActorLocal {
+  constructor() {
+    super();
+  }
+  
+  *data() {
+  }
+  
+  *run() {
+  }
+}
+
+module.exports = NotImplementedLocal;
+
+```

package/Documentation/abstractions/actor/Document-global-actor-originating.txt

@@ -0,0 +1,100 @@
+# **Actor Originating**
+
+## **Description**
+The [[REF=, ABS_Actor_Originating]] does have client capabilities. It means that it can use a [[REF=, ABS_Stack_Client_Connection]]s to setup connections and communicate with servers. The [[REF=, ABS_Actor_Originating]] can be used in all [[REF=, ABS_Test_Case_Phases]].
+
+## **States**
+The [[REF=, ABS_Actor_Originating]] supports the following [[REF=, ABS_Actor_State_Execution]]:
+* ***data**
+* ***initClient**
+* ***run**
+* ***exit**
+
+```state
+Title: ActorOriginating
+Config(width: 400, height: 200, widthBias: 25, heightBias: 25)
+
+States[data, initClient, run]
+States[, done, exit]
+
+data -> initClient[success]: success
+data -> done[failure]: error, failure, interrupt
+initClient -> run[success]: success
+initClient -> done[failure]: error, failure, interrupt
+run -> exit[normal]: always
+exit -> done[normal]: always
+```
+
+## **Example 1 - Actor Originating Wizard**
+Here is the code produced by the [[REF=, ABS_Actor_Originating]] Wizard.
+```javascript
+
+const ActorApi = require('actor-api');
+
+
+class NotImplementedOrig extends ActorApi.ActorOriginating {
+  constructor() {
+    super();
+    this.connection = this.create();
+  }
+  
+  *data() {
+  }
+  
+  *initClient() {
+    this.createConnection('[stack]', this.connection);
+  }
+  
+  *run() {
+  }
+  
+  *exit() {
+    this.closeConnection(this.connection);
+  }
+}
+
+module.exports = NotImplementedOrig;
+
+```
+
+## **Example 2 - static http**
+This is a very simple example where the [[REF=, ABS_Actor]] connects to a web server. It then sends an HTTP GET and verifies that it gets a response with the status code 200.
+
+```javascript
+
+
+const ActorApi = require('actor-api');
+const HttpApi = require('http-stack-api');
+const HttpMsgGetRequest = require('./msg/HttpMsgGetRequest');
+
+
+class StaticHttpActorOrig extends ActorApi.ActorOriginating {
+  constructor() {
+    super();
+    this.httpConnection = this.create();
+  }
+  
+  *data() {
+    this.requistUri = this.getTestDataString('Request-URI', '/demo');
+  }
+    
+  *initClient() {
+    this.createConnection('http', this.httpConnection);
+  }
+  
+  *run() {
+    this.httpConnection.send(new HttpMsgGetRequest(this.requistUri));
+    
+    const response = this.httpConnection.receive();
+    VERIFY_VALUE(HttpApi.StatusCode.OK, response.statusCode, ' HTTP response line status code:');
+    VERIFY_CONTENT_OPTIONAL('content-name', response.getHeaderNumber(HttpApi.Header.CONTENT_LENGTH), response.getBody());
+  }
+  
+  *exit() {
+    this.closeConnection(this.httpConnection);
+  }
+}
+
+module.exports = StaticHttpActorOrig;
+
+```