go.fuchsia.dev/infra@v0.0.0-20240507153436-9b593402251b/cmd/roller-configurator/resolve_test.go

// Copyright 2023 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package main

import (
	"context"
	"encoding/json"
	"strings"
	"testing"

	"github.com/google/go-cmp/cmp"
	"go.fuchsia.dev/infra/cmd/roller-configurator/proto"
	"google.golang.org/protobuf/encoding/prototext"
)

var testFiles = map[string]string{
	".gitmodules": `
		[submodule "path/to/submodule"]
			url = "https://example.com/lib"
	`,
	"path/to/jiri_manifest": `
		<?xml version="1.0" encoding="UTF-8"?>
		<manifest>
			<projects>
				<project name="foo-project"
						 remote="https://example.com/jiri-project"
						 anotherfield="bar"/>
			</projects>
			<packages>
				<package name="foo/package1/${platform}"
						 anotherfield="baz"/>
				<package name="foo/package2/${platform}"
						 anotherfield="baz"/>
			</packages>
		</manifest>
	`,
}

func TestResolve(t *testing.T) {
	t.Parallel()

	testCases := []struct {
		name  string
		input string
		want  string
	}{
		{
			name:  "empty",
			input: `rollers: []`,
			want:  `[]`,
		},
		{
			name: "submodule roller",
			input: `rollers: [
				{
					submodule: {
						path: "path/to/submodule"
					}
					schedule: "* * * * *"
				}
			]`,
			want: `[
				{
					"type": "submodule",
					"path": "path/to/submodule",
					"remote": "https://example.com/lib",
					"schedule": "* * * * *",
					"force_submit": false,
					"notify_emails": [],
					"owner_email": ""
				}
			]`,
		},
		{
			name: "jiri project roller",
			input: `rollers: [
				{
					jiri_project: {
						manifest: "path/to/jiri_manifest"
						project: "foo-project"
					}
				}
			]
			default_checkout_jiri_manifest: "manifest"
			`,
			want: `[
				{
					"type": "jiri_project",
					"manifest": "path/to/jiri_manifest",
					"project": "foo-project",
					"remote": "https://example.com/jiri-project",
					"remote_branch": "",
					"checkout_manifest": "manifest",
					"schedule": "",
					"force_submit": false,
					"notify_emails": [],
					"owner_email": ""
				}
			]`,
		},
		{
			name: "jiri package roller",
			input: `rollers: [
				{
					jiri_packages: {
						ref: "foo"
						manifests: [
							{
								path: "path/to/jiri_manifest"
								packages: [
									"foo/package1/${platform}"
								]
							}
						]
					}
				},
				{
					jiri_packages: {
						manifests: [
							{
								path: "path/to/jiri_manifest"
								packages: [
									"foo/package2/${platform}"
								]
							}
						]
					}
				}
			]
			default_checkout_jiri_manifest: "manifest"
			`,
			want: `[
				{
					"type": "jiri_packages",
					"manifests": [
						{
							"path": "path/to/jiri_manifest",
							"packages": [
								"foo/package1/${platform}"
							]
						}
					],
					"ref": "foo",
					"checkout_manifest": "manifest",
					"schedule": "",
					"force_submit": false,
					"owner_email": "",
					"notify_emails": []
				},
				{
					"type": "jiri_packages",
					"manifests": [
						{
							"path": "path/to/jiri_manifest",
							"packages": [
								"foo/package2/${platform}"
							]
						}
					],
					"ref": "latest",
					"checkout_manifest": "manifest",
					"schedule": "",
					"force_submit": false,
					"owner_email": "",
					"notify_emails": []
				}
			]`,
		},
	}

	for _, tc := range testCases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			var config proto.Config
			if err := prototext.Unmarshal([]byte(tc.input), &config); err != nil {
				t.Fatal(err)
			}

			repoRoot := t.TempDir()
			writeFiles(t, repoRoot, testFiles)

			var output strings.Builder
			if err := resolve(context.Background(), repoRoot, &config, &output); err != nil {
				t.Fatal(err)
			}

			got := formatJSON(t, output.String())
			want := formatJSON(t, tc.want)
			if diff := cmp.Diff(want, got); diff != "" {
				t.Errorf("Resolution diff (-want +got):\n%s", diff)
			}
		})
	}
}

func formatJSON(t *testing.T, jsonStr string) string {
	var m []map[string]any
	if err := json.Unmarshal([]byte(jsonStr), &m); err != nil {
		t.Fatal(err)
	}
	b, err := json.Marshal(m)
	if err != nil {
		t.Fatal(err)
	}
	return string(b)
}