github.com/gitbundle/modules@v0.0.0-20231025071548-85b91c5c3b01/packages/composer/metadata_test.go (about)

     1  // Copyright 2023 The GitBundle Inc. All rights reserved.
     2  // Copyright 2017 The Gitea Authors. All rights reserved.
     3  // Use of this source code is governed by a MIT-style
     4  // license that can be found in the LICENSE file.
     5  
     6  package composer
     7  
     8  import (
     9  	"archive/zip"
    10  	"bytes"
    11  	"strings"
    12  	"testing"
    13  
    14  	"github.com/gitbundle/modules/json"
    15  
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  const (
    20  	name        = "gitbundle/composer-package"
    21  	description = "Package Description"
    22  	packageType = "composer-plugin"
    23  	author      = "GitBundle Authors"
    24  	email       = "no.reply@gitbundle.com"
    25  	homepage    = "https://gitbunde.com"
    26  	license     = "MIT"
    27  )
    28  
    29  const composerContent = `{
    30      "name": "` + name + `",
    31      "description": "` + description + `",
    32      "type": "` + packageType + `",
    33      "license": "` + license + `",
    34      "authors": [
    35          {
    36              "name": "` + author + `",
    37              "email": "` + email + `"
    38          }
    39      ],
    40      "homepage": "` + homepage + `",
    41      "autoload": {
    42          "psr-4": {"GitBundle\\ComposerPackage\\": "src/"}
    43      },
    44      "require": {
    45          "php": ">=7.2 || ^8.0"
    46      }
    47  }`
    48  
    49  func TestLicenseUnmarshal(t *testing.T) {
    50  	var l Licenses
    51  	assert.NoError(t, json.NewDecoder(strings.NewReader(`["MIT"]`)).Decode(&l))
    52  	assert.Len(t, l, 1)
    53  	assert.Equal(t, "MIT", l[0])
    54  	assert.NoError(t, json.NewDecoder(strings.NewReader(`"MIT"`)).Decode(&l))
    55  	assert.Len(t, l, 1)
    56  	assert.Equal(t, "MIT", l[0])
    57  }
    58  
    59  func TestParsePackage(t *testing.T) {
    60  	createArchive := func(name, content string) []byte {
    61  		var buf bytes.Buffer
    62  		archive := zip.NewWriter(&buf)
    63  		w, _ := archive.Create(name)
    64  		w.Write([]byte(content))
    65  		archive.Close()
    66  		return buf.Bytes()
    67  	}
    68  
    69  	t.Run("MissingComposerFile", func(t *testing.T) {
    70  		data := createArchive("dummy.txt", "")
    71  
    72  		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
    73  		assert.Nil(t, cp)
    74  		assert.ErrorIs(t, err, ErrMissingComposerFile)
    75  	})
    76  
    77  	t.Run("MissingComposerFileInRoot", func(t *testing.T) {
    78  		data := createArchive("sub/sub/composer.json", "")
    79  
    80  		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
    81  		assert.Nil(t, cp)
    82  		assert.ErrorIs(t, err, ErrMissingComposerFile)
    83  	})
    84  
    85  	t.Run("InvalidComposerFile", func(t *testing.T) {
    86  		data := createArchive("composer.json", "")
    87  
    88  		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
    89  		assert.Nil(t, cp)
    90  		assert.Error(t, err)
    91  	})
    92  
    93  	t.Run("Valid", func(t *testing.T) {
    94  		data := createArchive("composer.json", composerContent)
    95  
    96  		cp, err := ParsePackage(bytes.NewReader(data), int64(len(data)))
    97  		assert.NoError(t, err)
    98  		assert.NotNil(t, cp)
    99  	})
   100  }
   101  
   102  func TestParseComposerFile(t *testing.T) {
   103  	t.Run("InvalidPackageName", func(t *testing.T) {
   104  		cp, err := ParseComposerFile(strings.NewReader(`{}`))
   105  		assert.Nil(t, cp)
   106  		assert.ErrorIs(t, err, ErrInvalidName)
   107  	})
   108  
   109  	t.Run("InvalidPackageVersion", func(t *testing.T) {
   110  		cp, err := ParseComposerFile(strings.NewReader(`{"name": "gitbundle/composer-package", "version": "1.a.3"}`))
   111  		assert.Nil(t, cp)
   112  		assert.ErrorIs(t, err, ErrInvalidVersion)
   113  	})
   114  
   115  	t.Run("Valid", func(t *testing.T) {
   116  		cp, err := ParseComposerFile(strings.NewReader(composerContent))
   117  		assert.NoError(t, err)
   118  		assert.NotNil(t, cp)
   119  
   120  		assert.Equal(t, name, cp.Name)
   121  		assert.Empty(t, cp.Version)
   122  		assert.Equal(t, description, cp.Metadata.Description)
   123  		assert.Len(t, cp.Metadata.Authors, 1)
   124  		assert.Equal(t, author, cp.Metadata.Authors[0].Name)
   125  		assert.Equal(t, email, cp.Metadata.Authors[0].Email)
   126  		assert.Equal(t, homepage, cp.Metadata.Homepage)
   127  		assert.Equal(t, packageType, cp.Type)
   128  		assert.Len(t, cp.Metadata.License, 1)
   129  		assert.Equal(t, license, cp.Metadata.License[0])
   130  	})
   131  }