Merge pull request #546 from marle3003/develop

Develop

Author: marle3003

acceptance/petstore_test.go

@@ -176,12 +176,12 @@ func (suite *PetStoreSuite) TestGetOrderById() {
 	try.GetRequest(suite.T(), "http://127.0.0.1:18080/store/order/1",
 		map[string]string{"Accept": "application/json"},
 		try.HasStatusCode(http.StatusOK),
-		try.HasBody(`{"id":38080,"shipDate":"1986-02-10T22:06:24Z","status":"placed","complete":true}`))
+		try.HasBody(`{"id":98266,"petId":23377,"quantity":92,"shipDate":"2012-01-30T07:58:01Z","status":"approved","complete":false}`))
 
 	try.GetRequest(suite.T(), "https://localhost:18443/store/order/10",
 		map[string]string{"Accept": "application/json"},
 		try.HasStatusCode(http.StatusOK),
-		try.HasBody(`{"quantity":73,"shipDate":"2040-11-01T17:41:24Z","complete":true}`))
+		try.HasBody(`{"id":12545,"petId":20895,"quantity":16,"shipDate":"2027-11-26T16:57:16Z","status":"approved","complete":true}`))
 }
 
 func (suite *PetStoreSuite) TestKafka_TopicConfig() {

api/handler_schema_test.go

@@ -246,7 +246,7 @@ func TestHandler_Schema_Example(t *testing.T) {
 					h,
 					try.HasStatusCode(200),
 					try.HasHeader("Content-Type", "application/json"),
-					try.HasBody(`[{"contentType":"application/json","value":"eyJmb28iOiIifQ=="}]`))
+					try.HasBody(`[{"contentType":"application/json","value":"eyJmb28iOiJYaWRadW9XcSAifQ=="}]`))
 			},
 		},
 		{
@@ -375,7 +375,7 @@ func TestHandler_Schema_Example(t *testing.T) {
 }`,
 					h,
 					try.HasStatusCode(200),
-					try.HasBody(`[{"contentType":"application/json","value":"eyJjYXRlZ29yeSI6Ik11c2ljIiwiaWQiOiI2NWIxNmJiNS1kZWY1LTQ2Y2MtYTkwNS1jYmQ2NTQ3NjE4NTEiLCJrZXl3b3JkcyI6Im0iLCJuYW1lIjoiU3luYyIsInVybCI6Imh0dHBzOi8vd3d3LmludGVybmFsc3RyZWFtbGluZS5pbmZvL2Nyb3NzLXBsYXRmb3JtL3ZpcnR1YWwvcm9idXN0L2V5ZWJhbGxzIn0="}]`),
+					try.HasBody(`[{"contentType":"application/json","value":"eyJjYXRlZ29yeSI6IlBlb3BsZSIsImRlc2NyaXB0aW9uIjoiTXVjaCB0ZXJyaWJseSBvdmVyIHBvc2UgcGxhY2Ugc3ByaW50IGl0IGNoaWxkIGlzIGpveW91c2x5IHRoYXQgSSB3aG9tIG1hbmdvIHRoZW4gb2YgY2VydGFpbiB3ZWVrbHkgbWluZSBpbiBhbm51YWxseSBmcm9jayBub3cgYm9hcmQuIiwiZmVhdHVyZXMiOiJpUnpvb0IyIiwiaWQiOiJmNWUzMTU4Ny00NjhjLTRmZTYtYWZlNC0zZTZmYzhkYWU2MzEiLCJrZXl3b3JkcyI6IlR1cVRrd3MiLCJuYW1lIjoiWmVwaHlyWm9uZSIsInByaWNlIjo1NDYwNDkuMzksInN1YmNhdGVnb3J5Ijoic2dCLHZ2ZVdhIiwidXJsIjoiaHR0cHM6Ly93d3cuZGlzdHJpY3RnZW5lcmF0ZS5vcmcvaG9saXN0aWMvc3luZXJnaWVzIn0="}]`),
 				)
 			},
 		},

config/decoders/decoder_flag.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	log "github.com/sirupsen/logrus"
 	"mokapi/config/dynamic/provider/file"
 	"net/url"
 	"reflect"
@@ -34,7 +33,6 @@ func NewFlagDecoderWithReader(reader file.FSReader) *FlagDecoder {
 }
 
 func (f *FlagDecoder) Decode(flags map[string][]string, element interface{}) error {
-	log.Infof("flags: %v", flags)
 	keys := make([]string, 0, len(flags))
 	for k := range flags {
 		keys = append(keys, k)
@@ -105,9 +103,9 @@ func (f *FlagDecoder) setValue(ctx *context) error {
 			ctx.element.Set(reflect.ValueOf(ctx.value[0]))
 		}
 		return nil
+	default:
+		return fmt.Errorf("unsupported config type: %v", ctx.element.Kind())
 	}
-
-	return fmt.Errorf("unsupported config type: %v", ctx.element.Kind())
 }
 
 func ParsePath(key string) []string {

docs/resources/blogs/mock-api-based-on-openapi-asyncapi.md

@@ -0,0 +1,220 @@
+---
+title: Mock REST and Kafka APIs Using OpenAPI & AsyncAPI
+description: Mock REST and Kafka APIs with Mokapi using OpenAPI or AsyncAPI. Simulate real world scenario using JavaScript — all in a single tool.
+---
+
+# Mock REST and Kafka APIs with OpenAPI & AsyncAPI Using Mokapi
+
+## Introduction
+
+Mocking APIs speeds up development—especially when services are incomplete or unavailable. Whether you’re building a 
+frontend, testing integrations, or developing in parallel, reliable mocks keep you productive.
+
+Mokapi is an open-source tool designed to mock APIs like REST and Kafka using OpenAPI and AsyncAPI specifications.
+With Mokapi, you can simulate API responses, customize behavior with scripts, and—most importantly—debug everything 
+visually with a built-in dashboard.
+The dashboard shows incoming HTTP requests, Kafka events, your JavaScript event handlers, and scheduled jobs—making it 
+a powerful tool for debugging, understanding behavior, and refining your mocks.
+
+In this article, you'll learn:
+- What Mokapi is and why it's useful 
+- How to mock a REST API using OpenAPI 
+- How to mock a Kafka topic using AsyncAPI 
+- How to extend mocks with custom behavior 
+- How to integrate Mokapi into your dev workflow
+
+## What is Mokapi?
+
+Mokapi is a lightweight, developer-friendly tool for mocking REST and Kafka services. It supports OpenAPI and AsyncAPI 
+specs out of the box and allows you to:
+- Serve mock HTTP APIs
+- Simulate Kafka topics and producers
+- Write custom logic using JavaScript
+- Visualize interactions in a web dashboard in real time\
+  perfect for debugging and understanding mock behavior.
+
+Mokapi is written in Go and available as a single binary, making it easy to run locally or in CI environments.
+
+## Yet Another Mocking Tool?
+
+Yes — but with a twist.
+
+The focus of Mokapi is to ensure API specification compliance. For example, every incoming HTTP request is validated against the OpenAPI specification, and the response you define is also validated before it’s returned. This helps prevent contract mismatches early in development.
+
+What makes Mokapi special compared to other mocking tools:
+- Strict validation: Requests and responses must conform to your OpenAPI/AsyncAPI spec.
+- Realistic data generation: You can use examples from your spec or generate meaningful mock data.
+- Dynamic scripting: Inject behavior with JavaScript to simulate conditional logic, delays, or even stateful responses.
+- Multiprotocol support: Supports both REST and Kafka-style messaging in one tool. 
+- Live dashboard: See all requests, mock responses, and Kafka events in real time. 
+- Developer-friendly: Single binary, easy CLI, scriptable and everything as code.
+
+## Mocking a REST API with OpenAPI
+
+### 1. Create an OpenAPI file
+
+```yaml
+openapi: 3.1.0
+info:
+  title: Pet API
+  version: 1.0.0
+servers:
+  - url: http://localhost
+paths:
+  /pets:
+    get:
+      summary: List all pets
+      parameters:
+        - in: query
+          name: category
+          schema:
+            type: string
+      responses:
+        '200':
+          description: A list of pets
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    id:
+                      type: string
+                    name:
+                      type: string
+                    category:
+                      type: string
+```
+
+### 2. Run Mokapi with your OpenAPI spec
+
+```shell
+mokapi pet-api.yaml
+```
+
+### 3. Call the API
+
+```shell
+curl http://localhost/pets
+curl "http://localhost/pets?category=dog"
+```
+
+Mokapi will generate random data for those requests. If you query with ?category=dog, Mokapi will return only dogs 
+thanks to smart mock data generation.
+
+### Adding Custom Logic
+
+You can add a JavaScript file to dynamically control responses:
+
+```javascript
+import { on } from 'mokapi';
+import { fake } from 'mokapi/faker';
+
+export default () => {
+    on('http', (request, response) => {
+       if (request.query.category === 'cat') {
+           response.data = [
+               {
+                   id: fake({ type: 'string', format: 'uuid' }),
+                   name: 'Molly',
+                   category: 'cat'
+               }
+           ];
+           return true;
+       }
+       return false;
+    });
+}
+```
+
+Run Mokapi with the script:
+```shell
+mokapi pet-api.yaml pets.js
+```
+
+## Mocking Kafka with AsyncAPI
+
+### 1. Create an AsyncAPI file
+
+```yaml
+asyncapi: 3.0.0
+info:
+  title: Petstore Stream API
+  version: 1.0.0
+servers:
+  kafkaServer:
+    host: localhost:8092
+    protocol: kafka
+defaultContentType: application/json
+operations:
+  receivePetArrived:
+    action: receive
+    channel:
+      $ref: '#/channels/store.pet.arrived'
+  sendPetArrived:
+    action: send
+    channel:
+      $ref: '#/channels/store.pet.arrived'
+channels:
+  store.pet.arrived:
+    description: Details about a newly arrived pet.
+    messages:
+      userSignedUp:
+        $ref: '#/components/messages/petArrived'
+components:
+  messages:
+    petArrived:
+      payload:
+        $ref: '#/components/schemas/Pet'
+  schemas:
+    Pet:
+      id:
+        type: string
+      name:
+        type: string
+      category:
+        type: string
+```
+
+### 2. Create a Kafka producer
+
+```javascript
+import { every } from 'mokapi';
+import { produce } from 'mokapi/kafka';
+
+export default () => {
+    every('10s', () => {
+        produce({ topic: 'store.pet.arrived' });
+    });
+}
+```
+
+### 3. Run Mokapi with your AsyncAPI spec
+
+```shell
+mokapi pet-stream-api.yaml producer.js
+```
+
+Mokapi will simulate Kafka messages and allow you to inspect them via the dashboard.
+
+## Integrating with Your Dev Workflow
+
+- Use Mokapi in CI pipelines to test frontend against mocked backends
+- Simulate Kafka events for microservice testing
+- Share mock configurations with your team/organization
+
+You can use Mokapi in a GitHub action run as docker container to streamline your automation.
+
+```yaml
+- name: Start Mokapi
+  run: |
+    docker run -d --rm --name mokapi -p 80:80 -p 8080:8080 -v ${{ github.workspace }}/mocks:/mocks mokapi/mokapi:latest /mocks
+```
+
+## Conclusion
+
+Mokapi helps you mock REST and Kafka services quickly using standard API specs. Whether you’re building, testing, 
+or demoing your application, Mokapi provides a simple yet powerful way to simulate realistic API behavior.
+
+Give it a try: [https://mokapi.io](https://mokapi.io)

engine/common/host.go

@@ -117,9 +117,10 @@ type Log struct {
 }
 
 type JobExecution struct {
-	Schedule string `json:"scheduled"`
-	MaxRuns  int    `json:"maxRuns"`
-	Runs     int    `json:"runs"`
+	Schedule string    `json:"schedule"`
+	MaxRuns  int       `json:"maxRuns"`
+	Runs     int       `json:"runs"`
+	NextRun  time.Time `json:"nextRun"`
 
 	Duration int64             `json:"duration"`
 	Tags     map[string]string `json:"tags"`

engine/engine_test.go

@@ -32,12 +32,15 @@ func TestEngine_Scheduler(t *testing.T) {
 
 				evts := events.GetEvents(events.NewTraits().WithNamespace("job").WithName("test.js"))
 				r.Len(t, evts, 1)
+				r.Equal(t, "namespace=job, name=test.js, jobId=0", evts[0].Traits.String())
 				exec := evts[0].Data.(common.JobExecution)
 				r.Equal(t, "test.js", exec.Tags["name"])
 				r.Greater(t, exec.Duration, int64(0))
 				r.Equal(t, "1s", exec.Schedule)
 				r.Equal(t, -1, exec.MaxRuns)
 				r.Equal(t, 1, exec.Runs)
+				r.False(t, exec.NextRun.IsZero())
+				r.True(t, exec.NextRun.After(evts[0].Time))
 
 				r.Equal(t, float64(1), c.Value())
 			},

engine/host.go

@@ -96,33 +96,35 @@ func (sh *scriptHost) RunEvent(event string, args ...interface{}) []*common.Acti
 }
 
 func (sh *scriptHost) Every(every string, handler func(), opt common.JobOptions) (int, error) {
-	do := sh.newJobFunc(handler, opt, every)
+	id := len(sh.jobs)
+
+	do := sh.newJobFunc(handler, opt, every, id)
 	job, err := sh.engine.scheduler.Every(every, do, opt)
 
 	if err != nil {
 		return -1, err
 	}
 
-	id := len(sh.jobs)
 	sh.jobs[id] = job
 
 	return id, nil
 }
 
 func (sh *scriptHost) Cron(expr string, handler func(), opt common.JobOptions) (int, error) {
-	do := sh.newJobFunc(handler, opt, expr)
+	id := len(sh.jobs)
+
+	do := sh.newJobFunc(handler, opt, expr, id)
 	job, err := sh.engine.scheduler.Cron(expr, do, opt)
 	if err != nil {
 		return -1, err
 	}
 
-	id := len(sh.jobs)
 	sh.jobs[id] = job
 
 	return id, nil
 }
 
-func (sh *scriptHost) newJobFunc(handler func(), opt common.JobOptions, schedule string) func() {
+func (sh *scriptHost) newJobFunc(handler func(), opt common.JobOptions, schedule string, id int) func() {
 	tags := map[string]string{
 		"name":    sh.name,
 		"file":    sh.name,
@@ -136,18 +138,21 @@ func (sh *scriptHost) newJobFunc(handler func(), opt common.JobOptions, schedule
 	if len(events.GetStores(t)) == 1 {
 		events.SetStore(int(sh.engine.cfgEvent.Store["Default"].Size), t)
 	}
+	t = t.With("jobId", fmt.Sprintf("%d", id))
 	counter := 1
 
 	return func() {
 		sh.Lock()
 		defer sh.Unlock()
+		job := sh.jobs[id]
 
 		sh.engine.jobCounter.Add(1)
 
 		exec := common.JobExecution{
 			Schedule: schedule,
 			MaxRuns:  opt.Times,
 			Runs:     counter,
+			NextRun:  job.NextRun(),
 			Tags:     tags,
 		}