BRAIN-43 - Templated manifest.xml

.github/workflows/app-release.yml

@@ -3,17 +3,18 @@ on:
   workflow_dispatch:
 
 jobs:
-  zip:
-    uses: shopware/github-actions/.github/workflows/build-zip.yml@main
-    with:
-      extensionName: SwagBraintreeApp
-
   release:
-    uses: shopware/github-actions/.github/workflows/store-release.yml@main
-    with:
-      extensionName: SwagBraintreeApp
-      publishOnly: true
-    secrets:
-      accountUser: ${{ secrets.SHOPWARE_ACCOUNT_USER }}
-      accountPassword: ${{ secrets.SHOPWARE_ACCOUNT_PASSWORD }}
-      ghToken: ${{ secrets.GITHUB_TOKEN }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup-php
+      - name: Generate manifest.xml
+        run: composer setup:manifest -- -f --env=prod
+      - uses: shopware/github-actions/store-release@main
+        with:
+          extensionName: SwagBraintreeApp
+          publishOnly: 'true'
+          skipCheckout: 'true'
+          accountUser: ${{ secrets.SHOPWARE_ACCOUNT_USER }}
+          accountPassword: ${{ secrets.SHOPWARE_ACCOUNT_PASSWORD }}
+          ghToken: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/app-zip.yml

@@ -0,0 +1,22 @@
+name: App Zip
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - 'Resources/**/*'
+      - 'templates/manifest.xml.twig'
+      - '.shopware-extension.yml'
+      - .github/workflows/app-zip.yml
+
+jobs:
+  zip:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/setup-php
+      - name: Generate manifest.xml
+        run: composer setup:manifest -- -f --env=prod
+      - uses: shopware/github-actions/build-zip@main
+        with:
+          extensionName: SwagBraintreeApp
+          skipCheckout: 'true'

.gitignore

@@ -32,3 +32,4 @@ public/build
 ###< vite ###
 
 Resources/app/storefront/dist
+manifest.xml

composer.json

@@ -81,12 +81,13 @@
             "bin/console doctrine:schema:drop --force --full-database",
             "bin/console doctrine:migrations:migrate -n",
             "@setup:url",
-            "@setup:test"
+            "@setup:manifest"
         ],
         "setup:url": [
             "bin/console setup:url",
             "npm run dev"
         ],
+        "setup:manifest": "bin/console manifest:generate",
         "setup:test": [
             "bin/console doctrine:schema:drop --env=test --force --full-database",
             "bin/console doctrine:migrations:migrate --env=test -n"

src/Command/ManifestGenerateCommand.php

@@ -0,0 +1,81 @@
+<?php declare(strict_types=1);
+
+namespace Swag\Braintree\Command;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Twig\Environment;
+
+#[AsCommand(name: 'manifest:generate')]
+class ManifestGenerateCommand extends Command
+{
+    public function __construct(
+        #[Autowire(env: 'APP_URL')]
+        private readonly ?string $appUrl,
+        #[Autowire(env: 'APP_SECRET')]
+        private readonly ?string $appSecret,
+        #[Autowire(param: 'kernel.environment')]
+        private readonly ?string $environment,
+        #[Autowire(param: 'kernel.project_dir')]
+        private readonly ?string $projectDir,
+        #[Autowire(service: 'twig')]
+        private readonly Environment $twig,
+    ) {
+        parent::__construct();
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+
+        if ($this->appUrl === null || $this->appSecret === null || $this->environment === null || $this->projectDir === null) {
+            $io->error('Missing environment variables');
+
+            return Command::FAILURE;
+        }
+
+        $manifest = $this->twig->render('manifest.xml.twig', [
+            'appUrl' => $this->environment === 'prod' ? 'https://braintree.shopware.com' : $this->appUrl,
+            'appSecret' => $this->appSecret,
+            'isProd' => $this->environment === 'prod',
+        ]);
+
+        $write = true;
+
+        if ($this->manifestExists() && !$input->getOption('force')) {
+            $write = $io->confirm('manifest.xml already exists. Do you want to overwrite it?', false);
+        }
+
+        if ($write) {
+            $success = $this->writeManifest($manifest);
+
+            if ($success === false) {
+                $io->error('Could not write manifest.xml');
+
+                return Command::FAILURE;
+            }
+        }
+
+        return Command::SUCCESS;
+    }
+
+    protected function configure(): void
+    {
+        $this->setDescription('Generate the manifest.xml');
+        $this->addOption('force', 'f', null, 'Force overwrite');
+    }
+
+    protected function manifestExists(): bool
+    {
+        return \file_exists($this->projectDir . '/manifest.xml');
+    }
+
+    protected function writeManifest(string $manifest): bool
+    {
+        return \file_put_contents($this->projectDir . '/manifest.xml', $manifest) !== false;
+    }
+}

manifest.xml → templates/manifest.xml.twig

@@ -18,29 +18,32 @@
     </meta>
 
     <setup>
-        <registrationUrl>https://braintree.shopware.com/app/lifecycle/register</registrationUrl>
+        <registrationUrl>{{ appUrl }}/app/lifecycle/register</registrationUrl>
+        {% if not isProd %}
+        <secret>{{ appSecret }}</secret>
+        {% endif %}
     </setup>
 
     <webhooks>
-        <webhook name="appActivated" url="https://braintree.shopware.com/app/lifecycle/activate" event="app.activated"/>
-        <webhook name="appDeactivated" url="https://braintree.shopware.com/app/lifecycle/deactivate" event="app.deactivated"/>
-        <webhook name="appDeleted" url="https://braintree.shopware.com/app/lifecycle/delete" event="app.deleted"/>
+        <webhook name="appActivated" url="{{ appUrl }}/app/lifecycle/activate" event="app.activated"/>
+        <webhook name="appDeactivated" url="{{ appUrl }}/app/lifecycle/deactivate" event="app.deactivated"/>
+        <webhook name="appDeleted" url="{{ appUrl }}/app/lifecycle/delete" event="app.deleted"/>
     </webhooks>
 
     <admin>
-        <base-app-url>https://braintree.shopware.com/admin-sdk</base-app-url>
+        <base-app-url>{{ appUrl }}/admin-sdk</base-app-url>
     </admin>
 
     <gateways>
-        <checkout>https://braintree.shopware.com/api/gateway/checkout</checkout>
+        <checkout>{{ appUrl }}/api/gateway/checkout</checkout>
     </gateways>
 
     <payments>
         <payment-method>
             <identifier>credit_card</identifier>
             <name>Credit or Debit Card (by Braintree)</name>
             <name lang="de-DE">Kredit- oder Debitkarte (von Braintree)</name>
-            <pay-url>https://braintree.shopware.com/api/pay</pay-url>
+            <pay-url>{{ appUrl }}/api/pay</pay-url>
             <icon>Resources/config/plugin.jpg</icon>
         </payment-method>
     </payments>

tests/unit/Command/ManifestGenerateCommandTest.php

@@ -0,0 +1,163 @@
+<?php declare(strict_types=1);
+
+namespace Swag\Braintree\Tests\Unit\Command;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Swag\Braintree\Command\ManifestGenerateCommand;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Twig\Environment;
+
+#[CoversClass(ManifestGenerateCommand::class)]
+class ManifestGenerateCommandTest extends TestCase
+{
+    private Environment&MockObject $twig;
+
+    private InputInterface&MockObject $input;
+
+    private OutputInterface&MockObject $output;
+
+    protected function setUp(): void
+    {
+        $this->twig = $this->createMock(Environment::class);
+        $this->input = $this->createMock(InputInterface::class);
+        $this->output = $this->createMock(OutputInterface::class);
+    }
+
+    #[DataProvider(methodName: 'provideFailOnAnyParameterMissing')]
+    public function testFailOnAnyParameterMissing(
+        ?string $appUrl,
+        ?string $appSecret,
+        ?string $environment,
+        ?string $projectDir,
+    ): void {
+        $this->output
+            ->expects(static::atLeastOnce())
+            ->method('writeln');
+
+        $command = $this->createCommand(
+            $appUrl,
+            $appSecret,
+            $environment,
+            $projectDir,
+        );
+
+        static::assertSame(ManifestGenerateCommand::FAILURE, $command->run($this->input, $this->output));
+    }
+
+    public static function provideFailOnAnyParameterMissing(): \Generator
+    {
+        yield 'appUrl missing' => [null, 'appSecret', 'environment', 'projectDir'];
+        yield 'appSecret missing' => ['appUrl', null, 'environment', 'projectDir'];
+        yield 'environment missing' => ['appUrl', 'appSecret', null, 'projectDir'];
+        yield 'projectDir missing' => ['appUrl', 'appSecret', 'environment', null];
+
+        yield 'appUrl and appSecret missing' => [null, null, 'environment', 'projectDir'];
+        yield 'appUrl and environment missing' => [null, 'appSecret', null, 'projectDir'];
+        yield 'appUrl and projectDir missing' => [null, 'appSecret', 'environment', null];
+        yield 'appSecret and environment missing' => ['appUrl', null, null, 'projectDir'];
+        yield 'appSecret and projectDir missing' => ['appUrl', null, 'environment', null];
+        yield 'environment and projectDir missing' => ['appUrl', 'appSecret', null, null];
+
+        yield 'only appUrl' => ['appUrl', null, null, null];
+        yield 'only appSecret' => [null, 'appSecret', null, null];
+        yield 'only environment' => [null, null, 'environment', null];
+        yield 'only projectDir' => [null, null, null, 'projectDir'];
+
+        yield 'all missing' => [null, null, null, null];
+    }
+
+    public function testRender(): void
+    {
+        $this->output
+            ->expects(static::never())
+            ->method('writeln');
+
+        $this->twig
+            ->expects(static::once())
+            ->method('render')
+            ->willReturn('manifest');
+
+        $command = $this->createCommand();
+
+        $command->expects(static::once())->method('manifestExists')->willReturn(false);
+        $command->expects(static::once())->method('writeManifest')->willReturn(true);
+
+        static::assertSame(ManifestGenerateCommand::SUCCESS, $command->run($this->input, $this->output));
+    }
+
+    public function testRenderUnsuccessfulWrite(): void
+    {
+        $this->output
+            ->expects(static::atLeastOnce())
+            ->method('writeln');
+
+        $this->twig
+            ->expects(static::once())
+            ->method('render')
+            ->willReturn('manifest');
+
+        $command = $this->createCommand();
+
+        $command->expects(static::once())->method('manifestExists')->willReturn(false);
+        $command->expects(static::once())->method('writeManifest')->willReturn(false);
+
+        static::assertSame(ManifestGenerateCommand::FAILURE, $command->run($this->input, $this->output));
+    }
+
+    public function testManifestExists(): void
+    {
+        $this->input
+            ->expects(static::once())
+            ->method('getOption')
+            ->with('force')
+            ->willReturn(false);
+
+        $command = $this->createCommand();
+
+        $command->expects(static::once())->method('manifestExists')->willReturn(true);
+        $command->expects(static::never())->method('writeManifest');
+
+        static::assertSame(ManifestGenerateCommand::SUCCESS, $command->run($this->input, $this->output));
+    }
+
+    public function testManifestExistsWithForce(): void
+    {
+        $this->input
+            ->expects(static::once())
+            ->method('getOption')
+            ->with('force')
+            ->willReturn(true);
+
+        $this->output
+            ->expects(static::never())
+            ->method('writeln');
+
+        $this->twig
+            ->expects(static::once())
+            ->method('render')
+            ->willReturn('manifest');
+
+        $command = $this->createCommand();
+
+        $command->expects(static::once())->method('manifestExists')->willReturn(true);
+        $command->expects(static::once())->method('writeManifest')->willReturn(true);
+
+        static::assertSame(ManifestGenerateCommand::SUCCESS, $command->run($this->input, $this->output));
+    }
+
+    protected function createCommand(
+        ?string $appUrl = 'appUrl',
+        ?string $appSecret = 'appSecret',
+        ?string $environment = 'environment',
+        ?string $projectDir = 'projectDir',
+    ): ManifestGenerateCommand&MockObject {
+        return $this->getMockBuilder(ManifestGenerateCommand::class)
+            ->onlyMethods(['manifestExists', 'writeManifest'])
+            ->setConstructorArgs([$appUrl, $appSecret, $environment, $projectDir, $this->twig])
+            ->getMock();
+    }
+}