core/installer/dodo_app_test.go

package installer

import (
	"bytes"
	"encoding/json"
	"fmt"
	"testing"

	"cuelang.org/go/cue/errors"
)

var exposed = `
input: {
  key: {
    private: "asd"
    public: "qwe"
  }
}
service: [{
    name: "app"
	type: "golang:1.20.0"
	run: "main.go"
	ingress: [{
		network: "private"
		subdomain: "testapp"
		auth: enabled: false
        port: name: "web"
	}]
    source: repository: "ssh://foo.bar"
    ports: [{
        name: "a"
        value: 100
    }, {
		name: "web"
		value: 8080
    }, {
		name: "b"
		value: 101
    }]
    expose: [{
		network: "private"
		subdomain: "1"
        port: value: 100
	}, {
		network: "public"
		subdomain:"2"
        port: name: "web"
	}, {
		network: "private"
		subdomain: "3"
        port: value: 101
    }],
    dev: enabled: false
}]

postgresql: [{
	name: "db_1"
	expose: [{
		network: "private"
		subdomain: "1"
	}, {
		network: "public"
		subdomain:"2"
	}, {
		network: "private"
		subdomain: "3"
	}]
}, {
	name: "db_2"
	expose: [{
		network: "public"
		subdomain: "1"
	}, {
		network: "private"
		subdomain:"2"
	}, {
		network: "public"
		subdomain: "3"
	}]
}]

mongodb: [{
	name: "mdb_1"
	expose: [{
		network: "public"
		subdomain: "1"
	}, {
		network: "private"
		subdomain:"2"
	}, {
		network: "public"
		subdomain: "3"
	}]
}, {
	name: "mdb_2"
	expose: [{
		network: "private"
		subdomain: "1"
	}, {
		network: "public"
		subdomain:"2"
	}, {
		network: "private"
		subdomain: "3"
	}]
}]
`

func TestExposedPorts(t *testing.T) {
	app, err := NewDodoApp([]byte(exposed))
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, nil, map[string]any{
		"managerAddr":            "",
		"appId":                  "",
		"sshPrivateKey":          "",
		"port_postgresql_db_1_0": 1,
		"port_postgresql_db_1_1": 2,
		"port_postgresql_db_1_2": 3,
		"port_postgresql_db_2_0": 4,
		"port_postgresql_db_2_1": 5,
		"port_postgresql_db_2_2": 6,
		"port_mongodb_mdb_1_0":   1,
		"port_mongodb_mdb_1_1":   2,
		"port_mongodb_mdb_1_2":   3,
		"port_mongodb_mdb_2_0":   4,
		"port_mongodb_mdb_2_1":   5,
		"port_mongodb_mdb_2_2":   6,
		"port_service_app_0":     7,
		"port_service_app_1":     8,
		"port_service_app_2":     9,
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
}

const canvas = `
{
    "service": [
        {
            "type": "nextjs:deno-2.0.0",
            "name": "app",
            "source": {
                "repository": "ssh://d.p.v1.dodo.cloud:62533/myblog",
                "branch": "master",
                "rootDir": "/"
            },
            "ports": [
                {
                    "name": "web",
                    "value": 3000,
                    "protocol": "TCP"
                }
            ],
            "env": [
                {
                    "name": "DODO_POSTGRESQL_DB_CONNECTION_URL"
                }
            ],
            "ingress": [{
                "network": "Private",
                "subdomain": "foo",
                "port": {
                    "name": "web"
                },
                "auth": {
                    "enabled": false
                }
            }, {
                "network": "Public",
                "subdomain": "foo",
                "port": {
                    "name": "web"
                },
                "auth": {
                    "enabled": false
                }
            }],
            "expose": [],
            "dev": { "enabled": true, "username": "gio" }
        }
    ],
    "volume": [],
    "postgresql": [
        {
            "name": "db",
            "size": "1Gi",
            "expose": []
        }
    ],
    "mongodb": []
}
`

func TestCanvas(t *testing.T) {
	app, err := NewDodoApp([]byte(canvas))
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, nil, map[string]any{
		"managerAddr":   "",
		"appId":         "",
		"sshPrivateKey": "",
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
}

const exposeRemoteClusterPrivateNetwork = `
{
    "cluster": "remote",
    "postgresql": [{
		"name": "db",
		"size": "1Gi",
		"expose": [{
			"network": "Private",
			"subdomain": "pg"
		}]
	}],
}
`

func TestExposeRemoteClusterPrivateNetwork(t *testing.T) {
	var buf bytes.Buffer
	if _, err := buf.WriteString(exposeRemoteClusterPrivateNetwork); err != nil {
		t.Fatal(err)
	}
	clusters := []Cluster{{
		Name:             "remote",
		Kubeconfig:       "<KUBECONFIG>",
		IngressClassName: "<INGRESS_CLASS_NAME>",
	}}
	if err := json.NewEncoder(&buf).Encode(struct {
		Clusters []Cluster `json:"clusters"`
	}{
		clusters,
	}); err != nil {
		t.Fatal(err)
	}
	app, err := NewDodoApp(buf.Bytes())
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, clusters, map[string]any{
		"managerAddr":                  "",
		"appId":                        "",
		"sshPrivateKey":                "",
		"port_postgresql_db_0":         1,
		"port_postgresql_db_0_cluster": 2,
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
	t.Log(fmt.Sprintf("%+v", r.Ports))
}

const exposeRemoteClusterPublicNetwork = `
{
    "cluster": "remote",
    "postgresql": [{
		"name": "db",
		"size": "1Gi",
		"expose": [{
			"network": "Public",
			"subdomain": "pg"
		}]
	}],
}
`

func TestExposeRemoteClusterPublicNetwork(t *testing.T) {
	var buf bytes.Buffer
	if _, err := buf.WriteString(exposeRemoteClusterPublicNetwork); err != nil {
		t.Fatal(err)
	}
	clusters := []Cluster{{
		Name:             "remote",
		Kubeconfig:       "<KUBECONFIG>",
		IngressClassName: "<INGRESS_CLASS_NAME>",
	}}
	if err := json.NewEncoder(&buf).Encode(struct {
		Clusters []Cluster `json:"clusters"`
	}{
		clusters,
	}); err != nil {
		t.Fatal(err)
	}
	app, err := NewDodoApp(buf.Bytes())
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, clusters, map[string]any{
		"managerAddr":                  "",
		"appId":                        "",
		"sshPrivateKey":                "",
		"port_postgresql_db_0":         1,
		"port_postgresql_db_0_cluster": 2,
		"port_postgresql_db_0_private": 3,
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
}

const exposeSVCRemoteCluster = `
{
  "cluster": "remote",
  "service": [
    {
      "name": "echo",
      "type": "golang:1.20.0",
      "source": {
        "repository": "ssh://foo.bar"
      },
      "ports": [
        {
          "name": "echo",
          "value": 9090
        }
      ],
      "expose": [
        {
          "port": {
            "name": "echo"
          },
          "network": "Private",
          "subdomain": "echo"
        }
      ],
      "dev": {
        "enabled": false
      }
    }
  ]
}
`

func TestExposeSVCRemoteCluster(t *testing.T) {
	var buf bytes.Buffer
	if _, err := buf.WriteString(exposeSVCRemoteCluster); err != nil {
		t.Fatal(err)
	}
	clusters := []Cluster{{
		Name:             "remote",
		Kubeconfig:       "<KUBECONFIG>",
		IngressClassName: "<INGRESS_CLASS_NAME>",
	}}
	if err := json.NewEncoder(&buf).Encode(struct {
		Clusters []Cluster `json:"clusters"`
	}{
		clusters,
	}); err != nil {
		t.Fatal(err)
	}
	app, err := NewDodoApp(buf.Bytes())
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, clusters, map[string]any{
		"managerAddr":                 "",
		"appId":                       "",
		"sshPrivateKey":               "",
		"port_service_echo_0":         1,
		"port_service_echo_0_cluster": 2,
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
	t.Log(fmt.Sprintf("%+v", r.Ports))
}

const sshCodeServer = `
{
  "service": [
    {
      "type": "nextjs:deno-2.0.0",
      "name": "app",
      "source": {
        "repository": "ssh://d.p.v1.dodo.cloud:62533/myblog",
        "branch": "master",
        "rootDir": "/"
      },
      "ports": [
        {
          "name": "web",
          "value": 3000,
          "protocol": "TCP"
        }
      ],
      "env": [
        {
          "name": "DODO_POSTGRESQL_DB_CONNECTION_URL"
        }
      ],
      "ingress": [
        {
          "network": "Private",
          "subdomain": "foo",
          "port": {
            "name": "web"
          },
          "auth": {
            "enabled": false
          }
        },
        {
          "network": "Public",
          "subdomain": "foo",
          "port": {
            "name": "web"
          },
          "auth": {
            "enabled": false
          }
        }
      ],
      "expose": [{
		"network": "Public",
		"subdomain": "foo",
		"port": {
		  "name": "web"
		},
      }],
      "dev": {
        "enabled": true,
        "username": "gio",
        "codeServer": {
          "network": "Private",
          "subdomain": "code"
        },
        "ssh": {
          "network": "Public",
          "subdomain": "ssh"
        }
      }
    }
  ],
  "volume": [],
  "postgresql": [
    {
      "name": "db",
      "size": "1Gi",
      "expose": []
    }
  ],
  "mongodb": []
}
`

func TestSSHCodeServer(t *testing.T) {
	app, err := NewDodoApp([]byte(sshCodeServer))
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, nil, map[string]any{
		"managerAddr":          "",
		"appId":                "",
		"sshPrivateKey":        "",
		"port_service_app_ssh": 12,
		"port_service_app_0":   13,
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
}

const foo = `
{
  "service": [
    {
      "type": "deno:2.2.0",
      "name": "qwe",
      "source": {
        "repository": "git@github.com:giolekva/dodo-blog.git"
      },
      "ports": [
        {
          "name": "web",
          "value": 8080,
          "protocol": "TCP"
        }
      ],
      "env": [
        {
          "name": "DODO_POSTGRESQL_DB_URL"
        },
        {
          "name": "DODO_PORT_WEB"
        }
      ],
      "ingress": [
        {
          "network": "Private",
          "subdomain": "blog",
          "port": {
            "name": "web"
          },
          "auth": {
            "enabled": false
          }
        }
      ],
      "expose": [
        {
          "network": "Private",
          "subdomain": "blog",
          "port": {
            "name": "web"
          }
        }
      ],
      "preBuildCommands": [],
      "dev": {
        "enabled": true,
        "username": "gio",
        "codeServer": {
          "network": "Private",
          "subdomain": "code"
        },
        "ssh": {
          "network": "Public",
          "subdomain": "code"
        }
      }
    }
  ],
  "volume": [],
  "postgresql": [
    {
      "name": "db",
      "size": "1Gi",
      "expose": [
        {
          "network": "Private",
          "subdomain": "pg"
        }
      ]
    }
  ],
  "mongodb": []
}
`

func TestFoo(t *testing.T) {
	app, err := NewDodoApp([]byte(foo))
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, nil, map[string]any{
		"managerAddr":          "",
		"appId":                "",
		"sshPrivateKey":        "",
		"port_service_qwe_ssh": 1,
		"port_service_qwe_0":   2,
		"port_postgresql_db_0": 3,
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	access, err := json.Marshal(r.Access)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(access))
}

const sketch = `
{
  "agent": [
    {
      "type": "sketch:latest",
      "name": "dev",
      "geminiApiKey": "foo",
      "ports": [
        {
          "name": "agent",
          "value": 2001,
          "protocol": "TCP"
        },
        {
          "name": "p8080",
          "value": 8080,
          "protocol": "TCP"
        },
        {
          "name": "p8081",
          "value": 8081,
          "protocol": "TCP"
        },
        {
          "name": "p8082",
          "value": 8082,
          "protocol": "TCP"
        },
        {
          "name": "p8083",
          "value": 8083,
          "protocol": "TCP"
        },
        {
          "name": "p8084",
          "value": 8084,
          "protocol": "TCP"
        }
      ]
    }
  ]
}
`

func TestSketch(t *testing.T) {
	app, err := NewDodoApp([]byte(sketch))
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, nil, map[string]any{
		"managerAddr":  "",
		"appId":        "",
		"geminiApiKey": "dev",
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
}

const sketchGlobalGeminiApiKey = `
{
    "agent": [
        {
            "type": "sketch:latest",
            "name": "dev",
        }
    ],
}
`

func TestSketchGlobalGeminiApiKey(t *testing.T) {
	app, err := NewDodoApp([]byte(sketchGlobalGeminiApiKey))
	if err != nil {
		for _, e := range errors.Errors(err) {
			t.Log(e)
		}
		t.Fatal(err)
	}
	release := Release{
		Namespace:     "foo",
		AppInstanceId: "foo-bar",
		RepoAddr:      "ssh://192.168.100.210:22/config",
		AppDir:        "/foo/bar",
	}
	keyGen := testKeyGen{}
	r, err := app.Render(release, env, networks, nil, map[string]any{
		"managerAddr":  "",
		"appId":        "",
		"geminiApiKey": "dev",
	}, nil, keyGen)
	if err != nil {
		t.Fatal(err)
	}
	t.Log(string(r.Raw))
}