Merge pull request #1 from hadiindrawan/dev

new version to main

Author: hadiindrawan

.gitignore

@@ -1,9 +1,7 @@
 node_modules
 package-lock.json
 .env
-.example.env
 tests
 runner
 mochawesome-report
-notes.txt
-*.json
+notes.txt

README.md

@@ -1,42 +1,32 @@
 
 # Automation API Generator
 
-This project has created to relieve work load as SDET or Automation Test Engineer. In moderation, automation API code able to write with only run the script and generate from Postman collection. You just export the collection, and run the Generator to write the automation code.
-
-
-
-
-## Features
-
-- Mocha chai generator
-
-
-## Installation
-
-First export your Postman collection which want to generate
-
-Clone the project repository to your directory and move json file (Postman collection export) to your directory  
-
-Install package with npm
-
-```bash
-  npm install
-```
-
-Run the generator with
-```bash
-   npm run generate <your-json-file>
-```
-
-Example:
-```bash
-   npm run generate MyProject.json
-```
-And, that's it, you just convert your Postman collection json file to Automation code (Mocha chai)
-## Configure your test
-
-To run tests, you should configure some file
-
-- If your scenario have some cases, you can using DDT (Data Driven Test), you can configure on test file in data variable
-- If you using json schema to validate the response, you just input each json response to json_response folder file
-- For run the test, you should configure the runner file
+This project has created to relieve work load as SDET or Automation Test Engineer. In moderation, automation API code able to write with only run the script and generate from Postman collection. You just export the collection and run the Generator to write the automation code.
+
+## Objectives
+
+1. Generate Postman collection with JSON format into Mocha-Chai template scripts
+2. Applying DDT (data-driven test) mechanism to request API with a lot of datas in body request
+3. Applying POM (page-object model) mechanism to request the API so it can be reused to another test file
+4. Have default verification for status code and json-schema
+5. Create scripts that easy to maintain
+
+## List of Contents:
+- [Prerequisite](docs/prerequisite.md)
+- [Installation](docs/installation.md)
+- [Lifecycle of Mocha Framework](docs/lifecycle.md)
+- [Folder Structure and Usage](docs/folder.md)
+  - [/runner](docs/folder.md#runner)
+  - [/tests/data](docs/folder.md#testsdata)
+  - [/tests/helper](docs/folder.md#testshelper)
+  - [/tests/pages](docs/folder.md#testspages)
+  - [/tests/scenarios](docs/folder.md#scenarios.md)
+  - [/tests/schema](docs/folder.md#testsschema)
+- [Scenarios](docs/scenarios.md)
+  - [Default templates](docs/scenarios.md#default-templates)
+  - [Default templates with body request](docs/scenarios.md#default-templates-with-body-request)
+- [Pages](docs/pages.md)
+  - [Default templates](docs/pages.md#default-templates)
+- [Implementation](docs/implementation.md)
+- [Best Practices](docs/practice.md)
+- [Common Error](docs/error.md)

docs/README.md

@@ -0,0 +1,34 @@
+
+# Automation API Generator
+
+This project has created to relieve work load as SDET or Automation Test Engineer. In moderation, automation API code able to write with only run the script and generate from Postman collection. You just export the collection, and run the Generator to write the automation code.
+
+## Objectives
+
+1. Generate Postman collection with JSON format into Mocha-Chai template scripts
+2. Applying DDT (data-driven test) mechanism to request API with a lot of datas in body request
+3. Applying POM (page-object model) mechanism to request the API so it can be reused to another test file
+4. Have default verification for status code and json-schema
+5. Create scripts that easy to maintain
+
+## List of Contents:
+- [Prerequisite](prerequisite.md)
+- [Installation](installation.md)
+- [Lifecycle of Mocha Framework](lifecycle.md)
+- [Folder Structure and Usage](folder.md)
+  - [/runner](folder.md#runner)
+  - [/tests/data](folder.md#testsdata)
+  - [/tests/helper](folder.md#testshelper)
+  - [/tests/pages](folder.md#testspages)
+  - [/tests/scenarios](folder.md#scenarios.md)
+  - [/tests/schema](folder.md#testsschema)
+- [Scenarios](scenarios.md)
+  - [Default templates](scenarios.md#default-templates)
+  - [Default templates with body request](scenarios.md#default-templates-with-body-request)
+- [Pages](pages.md)
+  - [Default templates](pages.md#default-templates)
+  - [Default templates with JSON body](pages.md#default-templates-with-json-body)
+  - [Default templates with attachment body](pages.md#default-templates-with-attachment-body)
+- [Implementation](implementation.md)
+- [Best Practices](practice.md)
+- [Common Error](error.md)

docs/error.md

@@ -0,0 +1,82 @@
+# Folder Structure and Usage
+
+## /runner
+Folder to store runners for each group of test files. You may create a new file to categorize wach file tests based on the needs.
+
+> It is generated automatically, grouped by your request folder in Postman collection. It will be stored by the order in which the requests are in your collection.
+
+For example:
+
+```javascript
+//file /runner/user.js
+require('../tests/scenarios/User/POST_register.spec')()
+require('../tests/scenarios/User/POST_login.spec')()
+module.exports = () => {}
+```
+
+The simple explanation:
+- This file is generated from a collection with request folder called User and 2 requests inside, which are:
+    1. Register
+    2. Login
+- This `user` runner will run your test file with `register` and `login` test name. The `register` test will be run first, then the `login` test.
+- `module.exports = () => {}` code section is used to export this file so you can user it in your regression test file (if needed) or other runner files.
+
+## /tests/data
+
+Folder to store data required for the tests. By default, it will be empty, you can easily configure it based on your needs.
+
+## /tests/helper
+
+Folder to store required functions or methods for global use. Default will be filled with `requestHelper.js`. You may ignore this file and create a new file for your use.
+
+## /tests/pages
+
+Folder to store the detail request of each API. For detailed explanation, you can go to [Pages](pages.md) section.
+
+## /tests/scenarios
+
+Folder to store your test files. It is linked closely with pages file, especially with the same name files. For detailed explanation, you can go to [Scenarios](scenarios.md) section.
+
+## /tests/schema
+
+It stores the JSON of response body (if any) that will be converted automatically into JSON-schema in `pages` file.
+
+> Data required is JSON response, not JSON-schema. You don't need to manually convert the JSON response to a JSON schema, because this template will do it!
+
+How to use this folder:
+1. Default file will be filled with key `success` and `failed`
+
+    You may use this key or create your own object to store the JSON value
+2. Prepare your JSON response that will be saved in a file along with its schema category
+    
+    For example:
+    ```json
+    //schema category -> success
+    //it's json response
+    {
+        "token": "1234567890",
+        "expires": "1970-01-01T00:00:00.00Z",
+        "status": "Success",
+        "result": "Success"
+    }
+    ```
+    
+3. Copy the predefined JSON response to value of key that match the category
+    
+    For example:
+    ```json
+    //file_name: login.json
+    {
+        "success":
+        {
+    		    "token": "1234567890",
+    		    "expires": "1970-01-01T00:00:00.00Z",
+    		    "status": "Success",
+    		    "result": "Success"
+    		},
+        "failed":
+        {
+            "example": "" 
+        }
+    }
+    ```

docs/folder.md

@@ -0,0 +1 @@
+# Implementation

docs/implementation.md

@@ -0,0 +1,67 @@
+# Installation
+
+1. Create your local project directory
+2. [Export your Postman collection](https://learning.postman.com/docs/getting-started/importing-and-exporting-data/#exporting-collections) to JSON with Collection v2.1 format
+3. Install package with npm
+   
+    ```bash
+    npm install dot-generator-mocha
+    ```
+1. Generate template Mocha-Chai script with command
+    ```bash
+    npx dot-generator-mocha '<your-file-path>'
+    ```
+    The file path can be absolute or relative, depending on where the file is stored.
+    For example, if your collection is stored in your local project directory:
+    ```bash
+    npx dot-generator-mocha 'My Project.postman_collection.json'
+    ```
+    or, if you use the absolute path:
+    ```bash
+    npx dot-generator-mocha 'C:\Users\Downloads\My Project.postman_collection.json'
+    ```
+1. Finish, the Mocha-CHai template scripts is successfully generated
+
+    How to check if it's success:
+    
+    If you have a Postman collection named "My Project" with a request inside a folder named "User".
+    - In the terminal, there is log with format:
+        ```bash
+        Generate Test tests/scenarios/<folder_name_of_Postman_collection>/<request_method>_<request_name>.spec.js
+        ```
+        For example:
+        ```bash
+        Generate Test tests/scenario/User/POST_login.spec.js
+        ```
+    - In the local directory:
+        - There are `tests` folder
+        - Inside `tests` folder, there are `pages`, `scenarios`, and `schema` folders
+        - Inside each that folder, there are folders which name same as the folder inside the Postman Collection
+        - Inside the folder there are files that has same name as the request Postman name
+        
+         For example, in the folder structure visualization:
+        ```js hl_lines="1 2"
+        ├───node_modules
+        ├───runner
+        ├───template
+        └───tests
+                ├───data
+                ├───helper
+                ├───pages
+                │   └───User
+                │       POST_login.js
+                ├───scenarios
+                │   └───User
+                │       POST_login.spec.js
+                └───schema
+                        └───User
+                        POST_login.json
+        ```
+        <!--Needs to be highlighted-->
+        The folder / file name with blue font is the newly generated files.
+2. Furhtermore, you can manage your test script files in your project directory
+    
+## Important information:
+    
+- For repetitive usage, the package will generate files based on new requests in your Postman collection and existing files will not be replaced
+- The package will read the existing test file name and do a comparison with the file to be generated. If the file to be generated does not exist, then the package will generate a new file.

docs/installation.md

@@ -0,0 +1,14 @@
+# Lifecycle of Mocha Framework
+
+After the template file is generated into your local directory, you can follow this lifecycle of Mocha framework:
+1. Complete test files to meet your scenario needs --> folder: `/tests/scenario`
+2. Configure request in `pages` file (if needed) --> folder: `/tests/pages`
+3. Complete JSON-schema file to cover all your defined scenario --> folder: `/tests/schema`
+4. Configure runner based on the defined test order --> folder: `runner`
+5. Run your test
+
+    You may use this command:
+    ```bash
+    npm run test
+    ```
+    Or you can configure new command in `package.json` file