fix reading LDIF files on Windows

fix generate JSON object if used: additionalProperties: false
update documentation for Kafka and LDAP

Author: marle3003

config/dynamic/directory/config.go

@@ -63,7 +63,11 @@ func (c *Config) Parse(config *dynamic.Config, reader dynamic.Reader) error {
 		if !u.IsAbs() {
 			if config.Info.Url != nil && config.Info.Url.Scheme == "file" {
 				if !filepath.IsAbs(file) {
-					dir := filepath.Dir(config.Info.Url.Path)
+					path := config.Info.Url.Path
+					if config.Info.Url.Opaque != "" {
+						path = config.Info.Url.Opaque
+					}
+					dir := filepath.Dir(path)
 					file = filepath.Join(dir, file)
 				}
 				file = filepath.Clean(file)

config/dynamic/directory/ldif.go

@@ -19,7 +19,8 @@ type LdifRecord interface {
 
 func (l *Ldif) Parse(config *dynamic.Config, reader dynamic.Reader) error {
 	l.Records = nil
-	lines := strings.Split(string(config.Raw), "\n")
+	s := strings.ReplaceAll(string(config.Raw), "\r\n", "\n")
+	lines := strings.Split(s, "\n")
 
 	if len(lines) > 0 {
 		kv := strings.SplitN(lines[0], ":", 2)

config/dynamic/dynamictest/reader.go

@@ -2,8 +2,10 @@ package dynamictest
 
 import (
 	"errors"
+	"fmt"
 	"mokapi/config/dynamic"
 	"net/url"
+	"strings"
 )
 
 var NotFound = errors.New("TestReader: config not found")
@@ -18,15 +20,18 @@ func (r *Reader) Read(u *url.URL, v any) (*dynamic.Config, error) {
 	if r.Data == nil {
 		return nil, NotFound
 	}
-	if c, ok := r.Data[u.String()]; ok {
+
+	path := cleanPath(u)
+
+	if c, ok := r.Data[path]; ok {
 		if c.Data == nil {
 			c.Data = v
 			err := dynamic.Parse(c, r)
 			return c, err
 		}
 
 		if p, isParser := c.Data.(dynamic.Parser); isParser {
-			if _, alreadyParsed := r.parsed[u.String()]; alreadyParsed {
+			if _, alreadyParsed := r.parsed[path]; alreadyParsed {
 				return c, nil
 			}
 			if err := p.Parse(c, r); err != nil {
@@ -37,7 +42,7 @@ func (r *Reader) Read(u *url.URL, v any) (*dynamic.Config, error) {
 				r.parsed = make(map[string]bool)
 			}
 
-			r.parsed[u.String()] = true
+			r.parsed[path] = true
 		}
 
 		return c, nil
@@ -50,3 +55,11 @@ type ReaderFunc func(u *url.URL, v any) (*dynamic.Config, error)
 func (f ReaderFunc) Read(u *url.URL, v any) (*dynamic.Config, error) {
 	return f(u, v)
 }
+
+func cleanPath(u *url.URL) string {
+	if u.Opaque != "" {
+		// Windows file path
+		return fmt.Sprintf("%s:%s", u.Scheme, strings.ReplaceAll(u.Opaque, "\\", "/"))
+	}
+	return u.String()
+}

docs/guides/kafka/overview.md

@@ -2,14 +2,23 @@
 title: How to mock Apache Kafka with Mokapi
 description: Mock your Kafka topics with AsyncAPI specification
 ---
-# Kafka
+# Mocking a Kafka Topic with Mokapi
+Mokapi simplifies the process of mocking Kafka topics, enabling you to efficiently test and debug your event-driven applications without the need for a live Kafka environment. Whether you’re validating message schemas, simulating producer-consumer workflows, or testing error-handling scenarios, Mokapi offers a flexible and developer-friendly solution.
 
-Kafka is a distributed streaming platform that is commonly used to build real-time data pipelines and streaming applications.
+Designed to integrate seamlessly into your projects, Mokapi allows you to mock Kafka brokers and topics using your AsyncAPI specifications. This ensures that your Kafka topics are simulated according to their contract, making it easier to prototype, test, and validate your systems with accuracy. Developers can also simulate Kafka producers and consumers with custom Mokapi Scripts, providing full control over message flows and test scenarios.
 
-## AsyncAPI
+## Key Features
 
-Mokapi with AsyncAPI can be used to simulate the behavior of a real Kafka system and test event-based applications.
-By using Mokapi you can create a test environment that is closely to the production environment.
-This allows you to identify and address issues before they impact the end-users.
-This reduces the risk of downtime and other issues in the production environment and improves the reliability and robustness of you application.
-Overall, Mokapi provides a powerful toolset for testing and validating event-based applications that rely on Kafka.
+**Mock Kafka Topics:** Use an AsyncAPI specification to mock Kafka topics by contract, ensuring consistency and adherence to expected behavior.
+
+**Schema Validation:** Mokapi validates message against the schemas to ensure compatibility and compliance between services, reducing runtime issues.
+
+**Realistic Test Data:** Import message payloads or generate representative data to test edge cases, workflows, and error conditions.
+
+**Streamlined Setup:** Avoid the complexity of setting up and maintaining a full Kafka environment, simplifying your development and testing process.
+
+## Why Use Mokapi for Kafka?
+By leveraging Mokapi, you can enhance your development workflow and reduce dependencies on external systems, while ensuring the reliability and robustness of your Kafka-based applications. The ability to simulate real-world scenarios and validate messages against contracts reduces the risk of issues in production, accelerates development, and supports a smooth CI/CD pipeline.
+
+## Start Mocking Today!
+Refer to [Quick Start](/docs/guides/kafka/quick-start.md) to learn how to create your first Kafka topic mock with Mokapi and streamline the process of testing and debugging event-driven architectures. Mokapi empowers you to build more reliable, scalable, and efficient systems, all while reducing the operational overhead of managing Kafka in your development environment.

docs/guides/ldap/overview.md

@@ -117,8 +117,7 @@ text: Success
 # numEntries: 3
 ```
 
-To query for the `cn=alice,dc=example,dc=com` user entry, use a command like.
-This command will return the details of the alice entry under dc=example,dc=com.
+To query the cn=alice,dc=example,dc=com user entry, you can use a command like the following:
 
 ```bash
 ldapsearch -x -h localhost -p 389 -b "dc=example,dc=com" "(cn=alice)"

ldap/client_test.go

@@ -73,7 +73,7 @@ func Dictionary() *Tree {
 			if s == nil {
 				return false
 			}
-			return s.AdditionalProperties != nil
+			return s.AdditionalProperties != nil && !s.AdditionalProperties.IsAny()
 		},
 		Fake: func(r *Request) (interface{}, error) {
 			s := r.LastSchema()

schema/json/generator/object.go

@@ -137,6 +137,93 @@ func TestObject(t *testing.T) {
 					v)
 			},
 		},
+		{
+			name: "no additional properties",
+			req: func() *Request {
+				return &Request{
+					Path: Path{
+						&PathElement{Schema: schematest.New("object",
+							schematest.WithProperty("name", schematest.New("string")),
+							schematest.WithFreeForm(false),
+						)},
+					},
+				}
+			},
+			test: func(t *testing.T, v interface{}, err error) {
+				require.NoError(t, err)
+				require.Equal(t, map[string]interface{}{"name": "Ink"}, v)
+			},
+		},
+		{
+			name: "with additional properties",
+			req: func() *Request {
+				return &Request{
+					Path: Path{
+						&PathElement{Schema: schematest.New("object",
+							schematest.WithProperty("name", schematest.New("string")),
+							schematest.WithFreeForm(true),
+						)},
+					},
+				}
+			},
+			test: func(t *testing.T, v interface{}, err error) {
+				require.NoError(t, err)
+				require.Equal(t, map[string]interface{}{"name": "Ink"}, v)
+			},
+		},
+		{
+			name: "with additional properties specific",
+			req: func() *Request {
+				return &Request{
+					Path: Path{
+						&PathElement{Schema: schematest.New("object",
+							schematest.WithAdditionalProperties(
+								schematest.New("object",
+									schematest.WithProperty("age", schematest.New("integer")),
+									schematest.WithProperty("gender", schematest.New("string")),
+									schematest.WithRequired("age", "gender"),
+								),
+							),
+						)},
+					},
+				}
+			},
+			test: func(t *testing.T, v interface{}, err error) {
+				require.NoError(t, err)
+				require.Equal(t,
+					map[string]interface{}{
+						"brace": map[string]interface{}{
+							"age":    int64(-2231804065324102411),
+							"gender": "female",
+						},
+						"child": map[string]interface{}{
+							"age":    int64(-5996906719781834924),
+							"gender": "male",
+						},
+						"comb": map[string]interface{}{
+							"age":    int64(298783498632242168),
+							"gender": "male",
+						},
+						"life": map[string]interface{}{
+							"age":    int64(-7574890634918414754),
+							"gender": "male",
+						},
+						"person": map[string]interface{}{
+							"age":    int64(-5048116001741826297),
+							"gender": "female",
+						},
+						"string": map[string]interface{}{
+							"age":    int64(-7377528278928660358),
+							"gender": "female",
+						},
+						"sunshine": map[string]interface{}{
+							"age":    int64(-3652171958352792229),
+							"gender": "male",
+						},
+					},
+					v)
+			},
+		},
 	}
 
 	for _, tc := range testcases {

schema/json/generator/object_test.go

@@ -0,0 +1,42 @@
+package schema
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestRef_MarshalJSON(t *testing.T) {
+	testcases := []struct {
+		name string
+		s    *Schema
+		test func(t *testing.T, s string, err error)
+	}{
+		{
+			name: "empty type",
+			s:    &Schema{},
+			test: func(t *testing.T, s string, err error) {
+				require.NoError(t, err)
+				require.Equal(t, "{}", s)
+			},
+		},
+		{
+			name: "with type",
+			s:    &Schema{Type: Types{"string"}},
+			test: func(t *testing.T, s string, err error) {
+				require.NoError(t, err)
+				require.Equal(t, `{"type":"string"}`, s)
+			},
+		},
+	}
+
+	t.Parallel()
+	for _, tc := range testcases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			b, err := json.Marshal(tc.s)
+			tc.test(t, string(b), err)
+		})
+	}
+}