From 2d6ab078be87edd30e871215a567c98dabb9b290 Mon Sep 17 00:00:00 2001
From: maddalax <jm@madev.me>
Date: Thu, 31 Oct 2024 11:59:19 -0500
Subject: [PATCH] swap tests

---
 framework/h/base_test.go | 141 +++++++++++++++++++++++++++++++++++++++
 framework/h/xhr_test.go  |  92 +++++++++++++++++++++++++
 2 files changed, 233 insertions(+)
 create mode 100644 framework/h/base_test.go
 create mode 100644 framework/h/xhr_test.go

diff --git a/framework/h/base_test.go b/framework/h/base_test.go
new file mode 100644
index 0000000..48540a3
--- /dev/null
+++ b/framework/h/base_test.go
@@ -0,0 +1,141 @@
+package h
+
+import (
+	"github.com/maddalax/htmgo/framework/hx"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewPage(t *testing.T) {
+	root := Div()
+	page := NewPage(root)
+
+	assert.Equal(t, http.MethodGet, page.HttpMethod)
+	assert.Equal(t, root, page.Root)
+}
+
+func TestEmptyPage(t *testing.T) {
+	page := EmptyPage()
+
+	assert.Equal(t, http.MethodGet, page.HttpMethod)
+	assert.Equal(t, Empty(), page.Root)
+}
+
+func TestNewPageWithHttpMethod(t *testing.T) {
+	root := Div()
+	page := NewPageWithHttpMethod(http.MethodPost, root)
+
+	assert.Equal(t, http.MethodPost, page.HttpMethod)
+	assert.Equal(t, root, page.Root)
+}
+
+func TestNewPartial(t *testing.T) {
+	root := Div()
+	partial := NewPartial(root)
+
+	assert.Nil(t, partial.Headers)
+	assert.Equal(t, root, partial.Root)
+}
+
+func TestNewPartialWithHeaders(t *testing.T) {
+	root := Div()
+	headers := NewHeaders("Content-Type", "application/json")
+	partial := NewPartialWithHeaders(headers, root)
+
+	assert.Equal(t, headers, partial.Headers)
+	assert.Equal(t, root, partial.Root)
+}
+
+func TestSwapManyPartialWithHeaders(t *testing.T) {
+	ctx := &RequestContext{isHxRequest: true}
+	headers := NewHeaders("HX-Trigger", "reload")
+	elements := []*Element{Div(), Span()}
+
+	partial := SwapManyPartialWithHeaders(ctx, headers, elements...)
+
+	assert.Equal(t, headers, partial.Headers)
+	assert.Equal(t, SwapMany(ctx, elements...), partial.Root)
+}
+
+func TestRedirectPartial(t *testing.T) {
+	partial := RedirectPartial("/new-path")
+	headers := NewHeaders("HX-Redirect", "/new-path")
+
+	assert.Equal(t, headers, partial.Headers)
+	assert.Equal(t, Empty(), partial.Root)
+}
+
+func TestRedirectPartialWithHeaders(t *testing.T) {
+	extraHeaders := NewHeaders("X-Custom", "value")
+	partial := RedirectPartialWithHeaders("/redirect-path", extraHeaders)
+
+	expectedHeaders := NewHeaders("HX-Redirect", "/redirect-path", "X-Custom", "value")
+	assert.Equal(t, expectedHeaders, partial.Headers)
+	assert.Equal(t, Empty(), partial.Root)
+}
+
+func TestIsEmptyPartial(t *testing.T) {
+	emptyPartial := EmptyPartial()
+	nonEmptyPartial := NewPartial(Div())
+
+	assert.True(t, IsEmptyPartial(emptyPartial))
+	assert.False(t, IsEmptyPartial(nonEmptyPartial))
+}
+
+func TestGetPartialPath(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	path := GetPartialPath(partial)
+
+	expectedSegment := "github.com/maddalax/htmgo/framework/h.TestGetPartialPath.func1"
+	assert.Contains(t, path, expectedSegment)
+}
+
+func TestGetPartialPathWithQs(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	qs := NewQs("param1", "value1", "param2", "value2")
+	pathWithQs := GetPartialPathWithQs(partial, qs)
+
+	assert.Contains(t, pathWithQs, "param1=value1&param2=value2")
+}
+
+func TestSwapManyPartial(t *testing.T) {
+	ctx := &RequestContext{isHxRequest: true}
+	element1 := Div()
+	element2 := Span()
+
+	partial := SwapManyPartial(ctx, element1, element2)
+
+	// Ensuring the elements have been marked for swap
+	assert.Equal(t, 1, len(element1.children))
+	assert.Equal(t, 1, len(element2.children))
+
+	assert.Equal(t, Attribute(hx.SwapOobAttr, hx.SwapTypeTrue), element1.children[0])
+	assert.Equal(t, Attribute(hx.SwapOobAttr, hx.SwapTypeTrue), element2.children[0])
+
+	// Test with non-HX request context
+	ctx.isHxRequest = false
+	partial = SwapManyPartial(ctx, element1, element2)
+	assert.True(t, IsEmptyPartial(partial))
+}
+
+func TestSwapPartial(t *testing.T) {
+	ctx := &RequestContext{isHxRequest: true}
+	element := Div()
+
+	partial := SwapPartial(ctx, element)
+
+	// Ensuring the element has been marked for swap
+	assert.Equal(t, 1, len(element.children))
+	assert.Equal(t, Attribute(hx.SwapOobAttr, hx.SwapTypeTrue), element.children[0])
+
+	// Test with non-HX request context
+	ctx.isHxRequest = false
+	partial = SwapPartial(ctx, element)
+	assert.True(t, IsEmptyPartial(partial))
+}
diff --git a/framework/h/xhr_test.go b/framework/h/xhr_test.go
new file mode 100644
index 0000000..2153a07
--- /dev/null
+++ b/framework/h/xhr_test.go
@@ -0,0 +1,92 @@
+package h
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestGet(t *testing.T) {
+	attr := Div(Get("/path", "load"))
+	assert.Equal(t, `<div hx-get="/path" hx-trigger="load"></div>`, Render(attr))
+}
+
+func TestGetPartial(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	attr := Div(GetPartial(partial, "load"))
+	expected := Render(Div(Get(GetPartialPath(partial), "load")))
+	assert.Equal(t, expected, Render(attr))
+}
+
+func TestGetPartialWithQs(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	qs := NewQs("param", "value")
+	attr := Div(GetPartialWithQs(partial, qs, "load"))
+	expectedPath := Render(Div(Get(GetPartialPathWithQs(partial, qs), "load")))
+	assert.Equal(t, expectedPath, Render(attr))
+}
+
+func TestPost(t *testing.T) {
+	attr := Div(Post("/path", "submit"))
+	assert.Equal(t, `<div hx-post="/path" hx-trigger="submit"></div>`, Render(attr))
+}
+
+func TestPostOnClick(t *testing.T) {
+	attr := Div(PostOnClick("/path"))
+	assert.Equal(t, `<div hx-post="/path" hx-trigger="click"></div>`, Render(attr))
+}
+
+func TestPostPartialOnClick(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	attr := Div(PostPartialOnClick(partial))
+	expected := Render(Div(PostOnClick(GetPartialPath(partial))))
+	assert.Equal(t, expected, Render(attr))
+}
+
+func TestPostPartialWithQs(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	qs := NewQs("key", "value")
+	attr := Div(PostPartialWithQs(partial, qs, "click"))
+	expected := Render(Div(Post(GetPartialPathWithQs(partial, qs), "click")))
+	assert.Equal(t, expected, Render(attr))
+}
+
+func TestPostPartialOnClickQs(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	qs := NewQs("key", "value")
+	attr := Div(PostPartialOnClickQs(partial, qs))
+	expected := Render(Div(PostOnClick(GetPartialPathWithQs(partial, qs))))
+	assert.Equal(t, expected, Render(attr))
+}
+
+func TestGetWithQs(t *testing.T) {
+	qs := NewQs("param1", "value1", "param2", "value2")
+	attr := Div(GetWithQs("/path", qs, "load"))
+	expected := `<div hx-get="/path?param1=value1&amp;param2=value2" hx-trigger="load"></div>`
+	assert.Equal(t, expected, Render(attr))
+}
+
+func TestPostWithQs(t *testing.T) {
+	qs := NewQs("param1", "value1", "param2", "value2")
+	attr := Div(PostWithQs("/path", qs, "submit"))
+	expected := `<div hx-post="/path?param1=value1&amp;param2=value2" hx-trigger="submit"></div>`
+	assert.Equal(t, expected, Render(attr))
+}
+
+func TestPostPartial(t *testing.T) {
+	partial := func(ctx *RequestContext) *Partial {
+		return &Partial{}
+	}
+	attr := Div(PostPartial(partial, "submit"))
+	expected := Render(Div(Post(GetPartialPath(partial), "submit")))
+	assert.Equal(t, expected, Render(attr))
+}