archtechx/tenancy
1
0
Fork 0
mirror of https://github.com/archtechx/tenancy.git synced 2025-12-12 17:44:04 +00:00
Code Activity

Merge branch 'master' of https://github.com/archtechx/tenancy into storage-url-conflict-resolution + migrate tests to Pest

Browse source
This commit is contained in:
lukinovec 2022-07-27 10:54:08 +02:00
commit 8aff44215d
90 changed files with 3867 additions and 3505 deletions
Download patch file Download diff file Expand all files Collapse all files

21
.github/ISSUE_TEMPLATE/bug-report.md vendored
View file

@ -1,21 +0,0 @@
---
name: "\U0001F41B Bug Report"
about: Report unexpected behavior with stancl/tenancy.
title: ''
labels: bug
assignees: stancl
---
#### Describe the bug
<!-- A clear and concise description of what the bug is. -->
#### Steps to reproduce
#### Expected behavior
A clear and concise description of what you expected to happen.
#### Your setup
- Laravel version: [e.g. 8.2.0]
- stancl/tenancy version: [e.g. 3.1.0]

48
.github/ISSUE_TEMPLATE/bug-report.yml vendored Normal file
View file

@ -0,0 +1,48 @@
name: 🐛 Bug Report
description: Report unexpected behavior with stancl/tenancy.
labels: ["bug"]
assignees:
- stancl
body:
- type: markdown
attributes:
value: |
Before opening a bug report, please search for the behaviour in the existing issues.
---
Thank you for taking the time to file a bug report. To address this bug as fast as possible, we need some information.
- type: textarea
id: bug-description
attributes:
label: Bug description
description: A clear and concise description of what the bug is.
validations:
required: true
- type: textarea
id: steps
attributes:
label: Steps to reproduce
description: Step-by-step guide for reproducing the bug in a fresh Laravel application.
validations:
required: true
- type: textarea
id: logs
attributes:
label: Expected behavior
description: A clear and concise description of what you expected to happen.
validations:
required: true
- type: input
id: laravel-version
attributes:
label: Laravel version
placeholder: "e.g. 8.2.0"
validations:
required: true
- type: input
id: tenancy-version
attributes:
label: stancl/tenancy version
placeholder: "e.g. 3.1.0"
validations:
required: true

29
.github/workflows/ci.yml vendored
View file

@ -2,12 +2,13 @@ name: CI
env:
COMPOSE_INTERACTIVE_NO_CLI: 1
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
on:
push:
branches: [ 3.x, 2.x, master ]
branches: [ master ]
pull_request:
branches: [ 3.x, 2.x, master ]
branches: [ master ]
jobs:
tests:
@ -15,8 +16,8 @@ jobs:
strategy:
matrix:
php: ["7.4", "8.0"]
laravel: ["^6.0", "^8.0"]
php: ["8.1"]
laravel: ["^9.0"]
steps:
- uses: actions/checkout@v2
@ -26,7 +27,19 @@ jobs:
run: docker-compose exec -T test composer require --no-interaction "laravel/framework:${{ matrix.laravel }}"
- name: Run tests
run: ./test
- name: Send code coverage to codecov
env:
CODECOV_TOKEN: 24382d15-84e7-4a55-bea4-c4df96a24a9b
run: bash <(curl -s https://codecov.io/bash)
php-cs-fixer:
name: Code style (php-cs-fixer)
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Install php-cs-fixer
run: composer global require friendsofphp/php-cs-fixer
- name: Run php-cs-fixer
run: $HOME/.composer/vendor/bin/php-cs-fixer fix --config=.php-cs-fixer.php
- name: Commit changes from php-cs-fixer
uses: EndBug/add-and-commit@v5
with:
author_name: "PHP CS Fixer"
author_email: "phpcsfixer@example.com"
message: Fix code style (php-cs-fixer)

4
.gitignore vendored
View file

@ -8,3 +8,7 @@ psysh
phpunit_var_*.xml
coverage/
clover.xml
tenant-schema-test.dump
tests/Etc/tmp/queuetest.json
docker-compose.override.yml
.php-cs-fixer.cache

141
.php-cs-fixer.php Normal file
View file

@ -0,0 +1,141 @@
<?php
use PhpCsFixer\Config;
use PhpCsFixer\Finder;
$rules = [
'array_syntax' => ['syntax' => 'short'],
'binary_operator_spaces' => [
'default' => 'single_space',
'operators' => [
'=>' => null,
'|' => 'no_space',
]
],
'blank_line_after_namespace' => true,
'blank_line_after_opening_tag' => true,
'no_superfluous_phpdoc_tags' => true,
'blank_line_before_statement' => [
'statements' => ['return']
],
'braces' => true,
'cast_spaces' => true,
'class_definition' => true,
'concat_space' => [
'spacing' => 'one'
],
'declare_equal_normalize' => true,
'elseif' => true,
'encoding' => true,
'full_opening_tag' => true,
'declare_strict_types' => true,
'fully_qualified_strict_types' => true, // added by Shift
'function_declaration' => true,
'function_typehint_space' => true,
'heredoc_to_nowdoc' => true,
'include' => true,
'increment_style' => ['style' => 'post'],
'indentation_type' => true,
'linebreak_after_opening_tag' => true,
'line_ending' => true,
'lowercase_cast' => true,
'constant_case' => true,
'lowercase_keywords' => true,
'lowercase_static_reference' => true, // added from Symfony
'magic_method_casing' => true, // added from Symfony
'magic_constant_casing' => true,
'method_argument_space' => true,
'native_function_casing' => true,
'no_alias_functions' => true,
'no_extra_blank_lines' => [
'tokens' => [
'extra',
'throw',
'use',
'use_trait',
]
],
'no_blank_lines_after_class_opening' => true,
'no_blank_lines_after_phpdoc' => true,
'no_closing_tag' => true,
'no_empty_phpdoc' => true,
'no_empty_statement' => true,
'no_leading_import_slash' => true,
'no_leading_namespace_whitespace' => true,
'no_mixed_echo_print' => [
'use' => 'echo'
],
'no_multiline_whitespace_around_double_arrow' => true,
'multiline_whitespace_before_semicolons' => [
'strategy' => 'no_multi_line'
],
'no_short_bool_cast' => true,
'no_singleline_whitespace_before_semicolons' => true,
'no_spaces_after_function_name' => true,
'no_spaces_around_offset' => true,
'no_spaces_inside_parenthesis' => true,
'no_trailing_comma_in_list_call' => true,
'no_trailing_comma_in_singleline_array' => true,
'no_trailing_whitespace' => true,
'no_trailing_whitespace_in_comment' => true,
'no_unneeded_control_parentheses' => true,
'no_unreachable_default_argument_value' => true,
'no_useless_return' => true,
'no_whitespace_before_comma_in_array' => true,
'no_whitespace_in_blank_line' => true,
'normalize_index_brace' => true,
'not_operator_with_successor_space' => true,
'object_operator_without_whitespace' => true,
'ordered_imports' => ['sort_algorithm' => 'alpha'],
'phpdoc_indent' => true,
'general_phpdoc_tag_rename' => true,
'phpdoc_no_access' => true,
'phpdoc_no_package' => true,
'phpdoc_no_useless_inheritdoc' => true,
'phpdoc_scalar' => true,
'phpdoc_single_line_var_spacing' => true,
'phpdoc_summary' => true,
'phpdoc_to_comment' => false,
'phpdoc_trim' => true,
'phpdoc_types' => true,
'phpdoc_var_without_name' => true,
'psr_autoloading' => true,
'self_accessor' => true,
'short_scalar_cast' => true,
'simplified_null_return' => false, // disabled by Shift
'single_blank_line_at_eof' => true,
'single_blank_line_before_namespace' => true,
'single_class_element_per_statement' => true,
'single_import_per_statement' => true,
'single_line_after_imports' => true,
'no_unused_imports' => true,
'single_line_comment_style' => [
'comment_types' => ['hash']
],
'single_quote' => true,
'space_after_semicolon' => true,
'standardize_not_equals' => true,
'switch_case_semicolon_to_colon' => true,
'switch_case_space' => true,
'ternary_operator_spaces' => true,
'trailing_comma_in_multiline' => true,
'trim_array_spaces' => true,
'unary_operator_spaces' => true,
'whitespace_after_comma_in_array' => true,
];
$project_path = getcwd();
$finder = Finder::create()
->in([
$project_path . '/src',
])
->name('*.php')
->notName('*.blade.php')
->ignoreDotFiles(true)
->ignoreVCS(true);
return (new Config())
->setFinder($finder)
->setRules($rules)
->setRiskyAllowed(true)
->setUsingCache(true);

7
.styleci.yml
View file

@ -1,7 +0,0 @@
risky: true
preset: laravel
enabled:
- declare_strict_types
disabled:
- concat_without_spaces
- ternary_operator_spaces

10
CONTRIBUTING.md
View file

@ -2,10 +2,14 @@
## Code style
StyleCI will flag code style violations in your pull requests.
php-cs-fixer will fix code style violations in your pull requests.
## Running tests
Run `docker-compose up -d` to start the containers. Then run `./test` to run the tests.
Run `composer docker-up` to start the containers. Then run `composer test` to run the tests.
When you're done testing, run `docker-compose down` to shut down the containers.
When you're done testing, run `composer docker-down` to shut down the containers.
### Docker on M1
Run `composer docker-m1` to symlink `docker-compose-m1.override.yml` to `docker-compose.override.yml`. This will reconfigure a few services in the docker compose config to be compatible with M1.

23
Dockerfile
View file

@ -1,7 +1,7 @@
ARG PHP_VERSION=7.4
ARG PHP_TARGET=php:${PHP_VERSION}-cli
FROM ${PHP_TARGET}
FROM --platform=linux/amd64 ${PHP_TARGET}
ARG COMPOSER_TARGET=2.0.3
@ -22,20 +22,29 @@ ENV LANG=en_GB.UTF-8
# Dockerfile _and pin the versions_! Eg:
# RUN pecl install memcached-2.2.0 && docker-php-ext-enable memcached
# install some OS packages we need
RUN apt-get update
RUN apt-get install -y --no-install-recommends libfreetype6-dev libjpeg62-turbo-dev libpng-dev libgmp-dev libldap2-dev netcat curl sqlite3 libsqlite3-dev libpq-dev libzip-dev unzip vim-tiny gosu git
# install php extensions
RUN apt-get update \
&& apt-get install -y gnupg2 \
&& curl https://packages.microsoft.com/keys/microsoft.asc | apt-key add - \
&& curl https://packages.microsoft.com/config/debian/11/prod.list > /etc/apt/sources.list.d/mssql-release.list \
&& apt-get update \
&& ACCEPT_EULA=Y apt-get install -y unixodbc-dev msodbcsql17
RUN apt-get install -y --no-install-recommends locales apt-transport-https libfreetype6-dev libjpeg62-turbo-dev libpng-dev libgmp-dev libldap2-dev netcat curl mariadb-client sqlite3 libsqlite3-dev libpq-dev libzip-dev unzip vim-tiny gosu git
RUN docker-php-ext-configure pgsql -with-pgsql=/usr/local/pgsql \
# && if [ "${PHP_VERSION}" = "7.4" ]; then docker-php-ext-configure gd --with-freetype --with-jpeg; else docker-php-ext-configure gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/; fi \
&& docker-php-ext-install -j$(nproc) gd pdo pdo_mysql pdo_pgsql pdo_sqlite pgsql zip gmp bcmath pcntl ldap sysvmsg exif \
# install the redis php extension
&& pecl install redis-5.3.2 \
&& pecl install redis-5.3.7 \
&& docker-php-ext-enable redis \
# install the pcov extention
&& pecl install pcov \
&& docker-php-ext-enable pcov \
&& echo "pcov.enabled = 1" > /usr/local/etc/php/conf.d/pcov.ini
&& echo "pcov.enabled = 1" > /usr/local/etc/php/conf.d/pcov.ini \
# install sqlsrv
&& pecl install sqlsrv pdo_sqlsrv \
&& docker-php-ext-enable sqlsrv pdo_sqlsrv
# clear the apt cache
RUN rm -rf /var/lib/apt/lists/* \
&& rm -rf /var/lib/apt/lists/* \

3
README.md
View file

@ -3,10 +3,9 @@
</p>
<p align="center">
<a href="https://laravel.com"><img alt="Laravel 6.x/7.x/8.x" src="https://img.shields.io/badge/laravel-6.x/7.x/8.x-red.svg"></a>
<a href="https://laravel.com"><img alt="Laravel 9.x" src="https://img.shields.io/badge/laravel-9.x-red.svg"></a>
<a href="https://packagist.org/packages/stancl/tenancy"><img alt="Latest Stable Version" src="https://poser.pugx.org/stancl/tenancy/version"></a>
<a href="https://github.com/stancl/tenancy/actions"><img alt="GitHub Actions CI status" src="https://github.com/stancl/tenancy/workflows/CI/badge.svg"></a>
<a href="https://codecov.io/gh/stancl/tenancy"><img alt="codecov" src="https://codecov.io/gh/stancl/tenancy/branch/3.x/graph/badge.svg"></a>
<a href="https://github.com/stancl/tenancy/blob/3.x/DONATIONS.md"><img alt="Donate" src="https://img.shields.io/badge/Donate-%3C3-red"></a>
</p>

2
SUPPORT.md
View file

@ -1,5 +1,5 @@
# Get Support
If you need help with implementing the package, you can join our community [Discord server](https://discord.gg/7cpgPxv) and ask in `#help`.
If you need help with implementing the package, you can join our community [Discord server](https://archte.ch/discord) and ask in `#help`.
If you're interested in paid consulting from the maintainer, see the [contact page](https://tenancyforlaravel.com/contact/) on our website.

8
assets/TenancyServiceProvider.stub.php
View file

@ -41,7 +41,13 @@ class TenancyServiceProvider extends ServiceProvider
Events\TenantSaved::class => [],
Events\UpdatingTenant::class => [],
Events\TenantUpdated::class => [],
Events\DeletingTenant::class => [],
Events\DeletingTenant::class => [
JobPipeline::make([
Jobs\DeleteDomains::class,
])->send(function (Events\DeletingTenant $event) {
return $event->tenant;
})->shouldBeQueued(false),
],
Events\TenantDeleted::class => [
JobPipeline::make([
Jobs\DeleteDatabase::class,

4
assets/config.php
View file

@ -42,7 +42,8 @@ return [
'central_connection' => env('DB_CONNECTION', 'central'),
/**
* Connection used as a "template" for the tenant database connection.
* Connection used as a "template" for the dynamically created tenant database connection.
* Note: don't name your template connection tenant. That name is reserved by package.
*/
'template_tenant_connection' => null,
@ -60,6 +61,7 @@ return [
'sqlite' => Stancl\Tenancy\TenantDatabaseManagers\SQLiteDatabaseManager::class,
'mysql' => Stancl\Tenancy\TenantDatabaseManagers\MySQLDatabaseManager::class,
'pgsql' => Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLDatabaseManager::class,
'sqlsrv' => Stancl\Tenancy\TenantDatabaseManagers\MicrosoftSQLDatabaseManager::class,
/**
* Use this database manager for MySQL to have a DB user created for each tenant database.

2
assets/migrations/2019_09_15_000020_create_domains_table.php
View file

@ -21,7 +21,7 @@ class CreateDomainsTable extends Migration
$table->string('tenant_id');
$table->timestamps();
$table->foreign('tenant_id')->references('id')->on('tenants')->onUpdate('cascade')->onDelete('cascade');
$table->foreign('tenant_id')->references('id')->on('tenants')->onUpdate('cascade');
});
}

42
composer.json
View file

@ -1,29 +1,35 @@
{
"name": "stancl/tenancy",
"description": "Automatic multi-tenancy for your Laravel application.",
"keywords": ["laravel", "multi-tenancy", "multi-database", "tenancy"],
"keywords": [
"laravel",
"multi-tenancy",
"multi-database",
"tenancy"
],
"license": "MIT",
"authors": [
{
"name": "Samuel Štancl",
"email": "samuel.stancl@gmail.com"
"email": "samuel@archte.ch"
}
],
"require": {
"php": "^8.1",
"ext-json": "*",
"illuminate/support": "^6.0|^7.0|^8.0",
"illuminate/support": "^9.0",
"facade/ignition-contracts": "^1.0",
"ramsey/uuid": "^3.7|^4.0",
"stancl/jobpipeline": "^1.0",
"stancl/virtualcolumn": "^1.0"
"ramsey/uuid": "^4.0",
"stancl/jobpipeline": "^1.6",
"stancl/virtualcolumn": "^1.2"
},
"require-dev": {
"vlucas/phpdotenv": "^3.3|^4.0|^5.0",
"laravel/framework": "^6.0|^7.0|^8.0",
"orchestra/testbench-browser-kit": "^4.0|^5.0|^6.0",
"league/flysystem-aws-s3-v3": "~1.0",
"laravel/framework": "^9.0",
"orchestra/testbench": "^7.0",
"league/flysystem-aws-s3-v3": "^3.0",
"doctrine/dbal": "^2.10",
"spatie/valuestore": "^1.2.5"
"spatie/valuestore": "^1.2.5",
"pestphp/pest": "^1.21"
},
"autoload": {
"psr-4": {
@ -49,6 +55,18 @@
}
}
},
"scripts": {
"docker-up": "PHP_VERSION=8.1 docker-compose up -d",
"docker-down": "PHP_VERSION=8.1 docker-compose down",
"docker-rebuild": "PHP_VERSION=8.1 docker-compose up -d --no-deps --build",
"docker-m1": "ln -s docker-compose-m1.override.yml docker-compose.override.yml",
"test": "PHP_VERSION=8.1 ./test"
},
"minimum-stability": "dev",
"prefer-stable": true
"prefer-stable": true,
"config": {
"allow-plugins": {
"pestphp/pest-plugin": true
}
}
}

7
docker-compose-m1.override.yml Normal file
View file

@ -0,0 +1,7 @@
services:
mysql:
platform: linux/amd64
mysql2:
platform: linux/amd64
mssql:
image: mcr.microsoft.com/azure-sql-edge

13
docker-compose.yml
View file

@ -4,7 +4,7 @@ services:
build:
context: .
args:
PHP_VERSION: ${PHP_VERSION}
PHP_VERSION: ${PHP_VERSION:-8.1}
depends_on:
mysql:
condition: service_healthy
@ -22,6 +22,9 @@ services:
TENANCY_TEST_REDIS_HOST: redis
TENANCY_TEST_MYSQL_HOST: mysql
TENANCY_TEST_PGSQL_HOST: postgres
TENANCY_TEST_SQLSRV_HOST: mssql
TENANCY_TEST_SQLSRV_USERNAME: sa
TENANCY_TEST_SQLSRV_PASSWORD: P@ssword
stdin_open: true
tty: true
mysql:
@ -64,3 +67,11 @@ services:
interval: 1s
timeout: 3s
retries: 30
mssql:
image: mcr.microsoft.com/mssql/server:2019-latest
ports:
- 1433:1433
environment:
- ACCEPT_EULA=Y
- SA_PASSWORD=P@ssword # todo reuse values from env above
# todo missing health check

1
src/Bootstrappers/DatabaseTenancyBootstrapper.php
View file

@ -6,6 +6,7 @@ namespace Stancl\Tenancy\Bootstrappers;
use Stancl\Tenancy\Contracts\TenancyBootstrapper;
use Stancl\Tenancy\Contracts\Tenant;
use Stancl\Tenancy\Contracts\TenantWithDatabase;
use Stancl\Tenancy\Database\DatabaseManager;
use Stancl\Tenancy\Exceptions\TenantDatabaseDoesNotExistException;

60
src/Bootstrappers/FilesystemTenancyBootstrapper.php
View file

@ -5,7 +5,6 @@ declare(strict_types=1);
namespace Stancl\Tenancy\Bootstrappers;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Filesystem\FilesystemAdapter;
use Illuminate\Support\Facades\Storage;
use League\Flysystem\Adapter\Local as LocalAdapter;
use Stancl\Tenancy\Contracts\TenancyBootstrapper;
@ -55,37 +54,39 @@ class FilesystemTenancyBootstrapper implements TenancyBootstrapper
}
// Storage facade
foreach ($this->app['config']['tenancy.filesystem.disks'] as $disk) {
/** @var FilesystemAdapter $filesystemDisk */
$filesystemDisk = Storage::disk($disk);
$this->originalPaths['disks']['path'][$disk] = $filesystemDisk->getAdapter()->getPathPrefix();
Storage::forgetDisk($this->app['config']['tenancy.filesystem.disks']);
if ($root = str_replace(
'%storage_path%',
storage_path(),
$this->app['config']["tenancy.filesystem.root_override.{$disk}"] ?? ''
)) {
$filesystemDisk->getAdapter()->setPathPrefix($finalPrefix = $root);
} else {
$root = $this->app['config']["filesystems.disks.{$disk}.root"];
$filesystemDisk->getAdapter()->setPathPrefix($finalPrefix = $root . "/{$suffix}");
foreach ($this->app['config']['tenancy.filesystem.disks'] as $disk) {
// todo@v4 \League\Flysystem\PathPrefixer is making this a lot more painful in flysystem v2
$diskConfig = $this->app['config']["filesystems.disks.{$disk}"];
$originalRoot = $diskConfig['root'] ?? null;
$this->originalPaths['disks']['path'][$disk] = $originalRoot;
$finalPrefix = str_replace(
['%storage_path%', '%tenant%'],
[storage_path(), $tenant->getTenantKey()],
$this->app['config']["tenancy.filesystem.root_override.{$disk}"] ?? '',
);
if (! $finalPrefix) {
$finalPrefix = $originalRoot
? rtrim($originalRoot, '/') . '/' . $suffix
: $suffix;
}
$this->app['config']["filesystems.disks.{$disk}.root"] = $finalPrefix;
// Storage Url
if ($filesystemDisk->getAdapter() instanceof LocalAdapter) {
$config = $filesystemDisk->getDriver()->getConfig();
$this->originalPaths['disks']['url'][$disk] = $config->has('url')
? $config->get('url')
: null;
if ($diskConfig['driver'] === 'local') {
$this->originalPaths['disks']['url'][$disk] = $diskConfig['url'] ?? null;
if ($url = str_replace(
'%tenant_id%',
$tenant->getTenantKey(),
$this->app['config']["tenancy.filesystem.url_override.{$disk}"] ?? ''
)) {
$config->set('url', url($url));
$this->app['config']["filesystems.disks.{$disk}.url"] = url($url);
}
}
}
@ -101,19 +102,16 @@ class FilesystemTenancyBootstrapper implements TenancyBootstrapper
$this->app['url']->setAssetRoot($this->app['config']['app.asset_url']);
// Storage facade
foreach ($this->app['config']['tenancy.filesystem.disks'] as $disk) {
/** @var FilesystemAdapter $filesystemDisk */
$filesystemDisk = Storage::disk($disk);
$root = $this->originalPaths['disks']['path'][$disk];
$filesystemDisk->getAdapter()->setPathPrefix($root);
$this->app['config']["filesystems.disks.{$disk}.root"] = $root;
Storage::forgetDisk($this->app['config']['tenancy.filesystem.disks']);
foreach ($this->app['config']['tenancy.filesystem.disks'] as $diskName) {
$this->app['config']["filesystems.disks.$diskName.root"] = $this->originalPaths['disks']['path'][$diskName];
$diskConfig = $this->app['config']['filesystems.disks.' . $diskName];
// Storage Url
if ($filesystemDisk->getAdapter() instanceof LocalAdapter && ! is_null($this->originalPaths['disks']['url'])) {
$config = $filesystemDisk->getDriver()->getConfig();
$config->set('url', $this->originalPaths['disks']['url']);
$url = $this->originalPaths['disks.url.' . $diskName] ?? null;
if ($diskConfig['driver'] === 'local' && ! is_null($url)) {
$$this->app['config']["filesystems.disks.$diskName.url"] = $url;
}
}
}

110
src/Bootstrappers/QueueTenancyBootstrapper.php
View file

@ -7,7 +7,10 @@ namespace Stancl\Tenancy\Bootstrappers;
use Illuminate\Config\Repository;
use Illuminate\Contracts\Events\Dispatcher;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Queue\Events\JobFailed;
use Illuminate\Queue\Events\JobProcessed;
use Illuminate\Queue\Events\JobProcessing;
use Illuminate\Queue\Events\JobRetryRequested;
use Illuminate\Queue\QueueManager;
use Illuminate\Support\Testing\Fakes\QueueFake;
use Stancl\Tenancy\Contracts\TenancyBootstrapper;
@ -21,6 +24,16 @@ class QueueTenancyBootstrapper implements TenancyBootstrapper
/** @var QueueManager */
protected $queue;
/**
* Don't persist the same tenant across multiple jobs even if they have the same tenant ID.
*
* This is useful when you're changing the tenant's state (e.g. properties in the `data` column) and want the next job to initialize tenancy again
* with the new data. Features like the Tenant Config are only executed when tenancy is initialized, so the re-initialization is needed in some cases.
*
* @var bool
*/
public static $forceRefresh = false;
/**
* The normal constructor is only executed after tenancy is bootstrapped.
* However, we're registering a hook to initialize tenancy. Therefore,
@ -28,7 +41,7 @@ class QueueTenancyBootstrapper implements TenancyBootstrapper
*/
public static function __constructStatic(Application $app)
{
static::setUpJobListener($app->make(Dispatcher::class));
static::setUpJobListener($app->make(Dispatcher::class), $app->runningUnitTests());
}
public function __construct(Repository $config, QueueManager $queue)
@ -39,25 +52,90 @@ class QueueTenancyBootstrapper implements TenancyBootstrapper
$this->setUpPayloadGenerator();
}
protected static function setUpJobListener($dispatcher)
protected static function setUpJobListener($dispatcher, $runningTests)
{
$dispatcher->listen(JobProcessing::class, function ($event) {
$tenantId = $event->job->payload()['tenant_id'] ?? null;
$previousTenant = null;
// The job is not tenant-aware
if (! $tenantId) {
return;
}
$dispatcher->listen(JobProcessing::class, function ($event) use (&$previousTenant) {
$previousTenant = tenant();
// Tenancy is already initialized for the tenant (e.g. dispatchNow was used)
if (tenancy()->initialized && tenant()->getTenantKey() === $tenantId) {
return;
}
// Tenancy was either not initialized, or initialized for a different tenant.
// Therefore, we initialize it for the correct tenant.
tenancy()->initialize(tenancy()->find($tenantId));
static::initializeTenancyForQueue($event->job->payload()['tenant_id'] ?? null);
});
if (version_compare(app()->version(), '8.64', '>=')) {
// JobRetryRequested only exists since Laravel 8.64
$dispatcher->listen(JobRetryRequested::class, function ($event) use (&$previousTenant) {
$previousTenant = tenant();
static::initializeTenancyForQueue($event->payload()['tenant_id'] ?? null);
});
}
// If we're running tests, we make sure to clean up after any artisan('queue:work') calls
$revertToPreviousState = function ($event) use (&$previousTenant, $runningTests) {
if ($runningTests) {
static::revertToPreviousState($event, $previousTenant);
}
};
$dispatcher->listen(JobProcessed::class, $revertToPreviousState); // artisan('queue:work') which succeeds
$dispatcher->listen(JobFailed::class, $revertToPreviousState); // artisan('queue:work') which fails
}
protected static function initializeTenancyForQueue($tenantId)
{
if (! $tenantId) {
// The job is not tenant-aware
if (tenancy()->initialized) {
// Tenancy was initialized, so we revert back to the central context
tenancy()->end();
}
return;
}
if (static::$forceRefresh) {
// Re-initialize tenancy between all jobs
if (tenancy()->initialized) {
tenancy()->end();
}
tenancy()->initialize(tenancy()->find($tenantId));
return;
}
if (tenancy()->initialized) {
// Tenancy is already initialized
if (tenant()->getTenantKey() === $tenantId) {
// It's initialized for the same tenant (e.g. dispatchNow was used, or the previous job also ran for this tenant)
return;
}
}
// Tenancy was either not initialized, or initialized for a different tenant.
// Therefore, we initialize it for the correct tenant.
tenancy()->initialize(tenancy()->find($tenantId));
}
protected static function revertToPreviousState($event, &$previousTenant)
{
$tenantId = $event->job->payload()['tenant_id'] ?? null;
// The job was not tenant-aware
if (! $tenantId) {
return;
}
// Revert back to the previous tenant
if (tenant() && $previousTenant && $previousTenant->isNot(tenant())) {
tenancy()->initialize($previousTenant);
}
// End tenancy
if (tenant() && (! $previousTenant)) {
tenancy()->end();
}
}
protected function setUpPayloadGenerator()

7
src/CacheManager.php
View file

@ -13,15 +13,16 @@ class CacheManager extends BaseCacheManager
*
* @param string $method
* @param array $parameters
* @return mixed
*/
public function __call($method, $parameters)
{
$tags = [config('tenancy.cache.tag_base') . tenant()->getTenantKey()];
if ($method === 'tags') {
if (count($parameters) !== 1) {
throw new \Exception("Method tags() takes exactly 1 argument. {count($parameters)} passed.");
$count = count($parameters);
if ($count !== 1) {
throw new \Exception("Method tags() takes exactly 1 argument. $count passed.");
}
$names = $parameters[0];

2
src/Commands/Install.php
View file

@ -24,8 +24,6 @@ class Install extends Command
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{

24
src/Commands/Migrate.php
View file

@ -8,39 +8,31 @@ use Illuminate\Contracts\Events\Dispatcher;
use Illuminate\Database\Console\Migrations\MigrateCommand;
use Illuminate\Database\Migrations\Migrator;
use Stancl\Tenancy\Concerns\DealsWithMigrations;
use Stancl\Tenancy\Concerns\ExtendsLaravelCommand;
use Stancl\Tenancy\Concerns\HasATenantsOption;
use Stancl\Tenancy\Events\DatabaseMigrated;
use Stancl\Tenancy\Events\MigratingDatabase;
class Migrate extends MigrateCommand
{
use HasATenantsOption, DealsWithMigrations;
use HasATenantsOption, DealsWithMigrations, ExtendsLaravelCommand;
/**
* The console command description.
*
* @var string
*/
protected $description = 'Run migrations for tenant(s)';
/**
* Create a new command instance.
*
* @param Migrator $migrator
* @param Dispatcher $dispatcher
*/
protected static function getTenantCommandName(): string
{
return 'tenants:migrate';
}
public function __construct(Migrator $migrator, Dispatcher $dispatcher)
{
parent::__construct($migrator, $dispatcher);
$this->setName('tenants:migrate');
$this->specifyParameters();
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
@ -55,7 +47,7 @@ class Migrate extends MigrateCommand
}
tenancy()->runForMultiple($this->option('tenants'), function ($tenant) {
$this->line("Tenant: {$tenant['id']}");
$this->line("Tenant: {$tenant->getTenantKey()}");
event(new MigratingDatabase($tenant));

6
src/Commands/MigrateFresh.php
View file

@ -7,6 +7,7 @@ namespace Stancl\Tenancy\Commands;
use Illuminate\Console\Command;
use Stancl\Tenancy\Concerns\DealsWithMigrations;
use Stancl\Tenancy\Concerns\HasATenantsOption;
use Symfony\Component\Console\Input\InputOption;
final class MigrateFresh extends Command
{
@ -23,13 +24,13 @@ final class MigrateFresh extends Command
{
parent::__construct();
$this->addOption('--drop-views', null, InputOption::VALUE_NONE, 'Drop views along with tenant tables.', null);
$this->setName('tenants:migrate-fresh');
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
@ -37,6 +38,7 @@ final class MigrateFresh extends Command
$this->info('Dropping tables.');
$this->call('db:wipe', array_filter([
'--database' => 'tenant',
'--drop-views' => $this->option('drop-views'),
'--force' => true,
]));

15
src/Commands/Rollback.php
View file

@ -7,13 +7,19 @@ namespace Stancl\Tenancy\Commands;
use Illuminate\Database\Console\Migrations\RollbackCommand;
use Illuminate\Database\Migrations\Migrator;
use Stancl\Tenancy\Concerns\DealsWithMigrations;
use Stancl\Tenancy\Concerns\ExtendsLaravelCommand;
use Stancl\Tenancy\Concerns\HasATenantsOption;
use Stancl\Tenancy\Events\DatabaseRolledBack;
use Stancl\Tenancy\Events\RollingBackDatabase;
class Rollback extends RollbackCommand
{
use HasATenantsOption, DealsWithMigrations;
use HasATenantsOption, DealsWithMigrations, ExtendsLaravelCommand;
protected static function getTenantCommandName(): string
{
return 'tenants:rollback';
}
/**
* The console command description.
@ -31,14 +37,11 @@ class Rollback extends RollbackCommand
{
parent::__construct($migrator);
$this->setName('tenants:rollback');
$this->specifyParameters();
$this->specifyTenantSignature();
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
@ -53,7 +56,7 @@ class Rollback extends RollbackCommand
}
tenancy()->runForMultiple($this->option('tenants'), function ($tenant) {
$this->line("Tenant: {$tenant['id']}");
$this->line("Tenant: {$tenant->getTenantKey()}");
event(new RollingBackDatabase($tenant));

5
src/Commands/Run.php
View file

@ -27,14 +27,11 @@ class Run extends Command
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
tenancy()->runForMultiple($this->option('tenants'), function ($tenant) {
$this->line("Tenant: {$tenant['id']}");
tenancy()->initialize($tenant);
$this->line("Tenant: {$tenant->getTenantKey()}");
$callback = function ($prefix = '') {
return function ($arguments, $argument) use ($prefix) {

4
src/Commands/Seed.php
View file

@ -35,8 +35,6 @@ class Seed extends SeedCommand
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
@ -51,7 +49,7 @@ class Seed extends SeedCommand
}
tenancy()->runForMultiple($this->option('tenants'), function ($tenant) {
$this->line("Tenant: {$tenant['id']}");
$this->line("Tenant: {$tenant->getTenantKey()}");
event(new SeedingDatabase($tenant));

53
src/Commands/TenantDump.php Normal file
View file

@ -0,0 +1,53 @@
<?php
declare(strict_types=1);
namespace Stancl\Tenancy\Commands;
use Illuminate\Console\Command;
use Illuminate\Contracts\Events\Dispatcher;
use Illuminate\Database\ConnectionResolverInterface;
use Illuminate\Database\Console\DumpCommand;
use Stancl\Tenancy\Contracts\Tenant;
use Symfony\Component\Console\Input\InputOption;
class TenantDump extends DumpCommand
{
public function __construct()
{
parent::__construct();
$this->setName('tenants:dump');
$this->specifyParameters();
}
public function handle(ConnectionResolverInterface $connections, Dispatcher $dispatcher): int
{
$this->tenant()->run(fn () => parent::handle($connections, $dispatcher));
return Command::SUCCESS;
}
public function tenant(): Tenant
{
$tenant = $this->option('tenant')
?? tenant()
?? $this->ask('What tenant do you want to dump the schema for?')
?? tenancy()->query()->first();
if (! $tenant instanceof Tenant) {
$tenant = tenancy()->find($tenant);
}
throw_if(! $tenant, 'Could not identify the tenant to use for dumping the schema.');
return $tenant;
}
protected function getOptions(): array
{
return array_merge([
['tenant', null, InputOption::VALUE_OPTIONAL, '', null],
], parent::getOptions());
}
}

6
src/Commands/TenantList.php
View file

@ -25,8 +25,6 @@ class TenantList extends Command
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
@ -36,9 +34,9 @@ class TenantList extends Command
->cursor()
->each(function (Tenant $tenant) {
if ($tenant->domains) {
$this->line("[Tenant] id: {$tenant['id']} @ " . implode('; ', $tenant->domains->pluck('domain')->toArray() ?? []));
$this->line("[Tenant] {$tenant->getTenantKeyName()}: {$tenant->getTenantKey()} @ " . implode('; ', $tenant->domains->pluck('domain')->toArray() ?? []));
} else {
$this->line("[Tenant] id: {$tenant['id']}");
$this->line("[Tenant] {$tenant->getTenantKeyName()}: {$tenant->getTenantKey()}");
}
});
}

25
src/Concerns/ExtendsLaravelCommand.php Normal file
View file

@ -0,0 +1,25 @@
<?php
declare(strict_types=1);
namespace Stancl\Tenancy\Concerns;
trait ExtendsLaravelCommand
{
protected function specifyTenantSignature(): void
{
$this->specifyParameters();
}
public function getName(): ?string
{
return static::getTenantCommandName();
}
public static function getDefaultName(): ?string
{
return static::getTenantCommandName();
}
abstract protected static function getTenantCommandName(): string;
}

2
src/Concerns/HasATenantsOption.php
View file

@ -12,7 +12,7 @@ trait HasATenantsOption
protected function getOptions()
{
return array_merge([
['tenants', null, InputOption::VALUE_IS_ARRAY | InputOption::VALUE_OPTIONAL, '', null],
['tenants', null, InputOption::VALUE_IS_ARRAY|InputOption::VALUE_OPTIONAL, '', null],
], parent::getOptions());
}

10
src/Contracts/TenantDatabaseManager.php
View file

@ -20,18 +20,11 @@ interface TenantDatabaseManager
/**
* Does a database exist.
*
* @param string $name
* @return bool
*/
public function databaseExists(string $name): bool;
/**
* Make a DB connection config array.
*
* @param array $baseConfig
* @param string $databaseName
* @return array
*/
public function makeConnectionConfig(array $baseConfig, string $databaseName): array;
@ -39,9 +32,6 @@ interface TenantDatabaseManager
* Set the DB connection that should be used by the tenant database manager.
*
* @throws NoConnectionSetException
*
* @param string $connection
* @return void
*/
public function setConnection(string $connection): void;
}

3
src/Database/Concerns/TenantRun.php
View file

@ -11,9 +11,6 @@ trait TenantRun
/**
* Run a callback in this tenant's context.
* Atomic, safely reverts to previous context.
*
* @param callable $callback
* @return mixed
*/
public function run(callable $callback)
{

33
src/Database/DatabaseManager.php
View file

@ -7,10 +7,12 @@ namespace Stancl\Tenancy\Database;
use Illuminate\Config\Repository;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Database\DatabaseManager as BaseDatabaseManager;
use Stancl\Tenancy\Contracts\ManagesDatabaseUsers;
use Stancl\Tenancy\Contracts\TenantCannotBeCreatedException;
use Stancl\Tenancy\Contracts\TenantWithDatabase;
use Stancl\Tenancy\Exceptions\DatabaseManagerNotRegisteredException;
use Stancl\Tenancy\Exceptions\TenantDatabaseAlreadyExistsException;
use Stancl\Tenancy\Exceptions\TenantDatabaseUserAlreadyExistsException;
/**
* @internal Class is subject to breaking changes in minor and patch versions.
@ -38,7 +40,7 @@ class DatabaseManager
*/
public function connectToTenant(TenantWithDatabase $tenant)
{
$this->database->purge('tenant');
$this->purgeTenantConnection();
$this->createTenantConnection($tenant);
$this->setDefaultConnection('tenant');
}
@ -48,10 +50,7 @@ class DatabaseManager
*/
public function reconnectToCentral()
{
if (tenancy()->initialized) {
$this->database->purge('tenant');
}
$this->purgeTenantConnection();
$this->setDefaultConnection($this->config->get('tenancy.database.central_connection'));
}
@ -60,7 +59,7 @@ class DatabaseManager
*/
public function setDefaultConnection(string $connection)
{
$this->app['config']['database.default'] = $connection;
$this->config['database.default'] = $connection;
$this->database->setDefaultConnection($connection);
}
@ -69,7 +68,19 @@ class DatabaseManager
*/
public function createTenantConnection(TenantWithDatabase $tenant)
{
$this->app['config']['database.connections.tenant'] = $tenant->database()->connection();
$this->config['database.connections.tenant'] = $tenant->database()->connection();
}
/**
* Purge the tenant database connection.
*/
public function purgeTenantConnection()
{
if (array_key_exists('tenant', $this->database->getConnections())) {
$this->database->purge('tenant');
}
unset($this->config['database.connections.tenant']);
}
/**
@ -81,8 +92,14 @@ class DatabaseManager
*/
public function ensureTenantCanBeCreated(TenantWithDatabase $tenant): void
{
if ($tenant->database()->manager()->databaseExists($database = $tenant->database()->getName())) {
$manager = $tenant->database()->manager();
if ($manager->databaseExists($database = $tenant->database()->getName())) {
throw new TenantDatabaseAlreadyExistsException($database);
}
if ($manager instanceof ManagesDatabaseUsers && $manager->userExists($username = $tenant->database()->getUsername())) {
throw new TenantDatabaseUserAlreadyExistsException($username);
}
}
}

5
src/Database/Models/ImpersonationToken.php
View file

@ -22,10 +22,15 @@ class ImpersonationToken extends Model
use CentralConnection;
protected $guarded = [];
public $timestamps = false;
protected $primaryKey = 'token';
public $incrementing = false;
protected $table = 'tenant_user_impersonation_tokens';
protected $dates = [
'created_at',
];

2
src/Database/Models/Tenant.php
View file

@ -29,7 +29,9 @@ class Tenant extends Model implements Contracts\Tenant
Concerns\InvalidatesResolverCache;
protected $table = 'tenants';
protected $primaryKey = 'id';
protected $guarded = [];
public function getTenantKeyName(): string

5
src/DatabaseConfig.php
View file

@ -80,8 +80,6 @@ class DatabaseConfig
/**
* Generate DB name, username & password and write them to the tenant model.
*
* @return void
*/
public function makeCredentials(): void
{
@ -113,7 +111,8 @@ class DatabaseConfig
$templateConnection = config("database.connections.{$template}");
return $this->manager()->makeConnectionConfig(
array_merge($templateConnection, $this->tenantConfig()), $this->getName()
array_merge($templateConnection, $this->tenantConfig()),
$this->getName()
);
}

2
src/Exceptions/TenantCouldNotBeIdentifiedById.php
View file

@ -9,7 +9,7 @@ use Facade\IgnitionContracts\ProvidesSolution;
use Facade\IgnitionContracts\Solution;
use Stancl\Tenancy\Contracts\TenantCouldNotBeIdentifiedException;
// todo: in v3 this should be suffixed with Exception
// todo: in v4 this should be suffixed with Exception
class TenantCouldNotBeIdentifiedById extends TenantCouldNotBeIdentifiedException implements ProvidesSolution
{
public function __construct($tenant_id)

10
src/Features/UniversalRoutes.php
View file

@ -23,11 +23,17 @@ class UniversalRoutes implements Feature
public function bootstrap(Tenancy $tenancy): void
{
foreach (static::$identificationMiddlewares as $middleware) {
$middleware::$onFail = function ($exception, $request, $next) {
$originalOnFail = $middleware::$onFail;
$middleware::$onFail = function ($exception, $request, $next) use ($originalOnFail) {
if (static::routeHasMiddleware($request->route(), static::$middlewareGroup)) {
return $next($request);
}
if ($originalOnFail) {
return $originalOnFail($exception, $request, $next);
}
throw $exception;
};
}
@ -40,7 +46,7 @@ class UniversalRoutes implements Feature
}
// Loop one level deep and check if the route's middleware
// groups have the searhced middleware group inside them
// groups have the searched middleware group inside them
$middlewareGroups = Router::getMiddlewareGroups();
foreach ($route->gatherMiddleware() as $inner) {
if (! $inner instanceof Closure && isset($middlewareGroups[$inner]) && in_array($middleware, $middlewareGroups[$inner], true)) {

1
src/Features/UserImpersonation.php
View file

@ -33,7 +33,6 @@ class UserImpersonation implements Feature
*
* @param string|ImpersonationToken $token
* @param int $ttl
* @return RedirectResponse
*/
public static function makeResponse($token, int $ttl = null): RedirectResponse
{

2
src/Jobs/CreateDatabase.php
View file

@ -36,8 +36,8 @@ class CreateDatabase implements ShouldQueue
return false;
}
$databaseManager->ensureTenantCanBeCreated($this->tenant);
$this->tenant->database()->makeCredentials();
$databaseManager->ensureTenantCanBeCreated($this->tenant);
$this->tenant->database()->manager()->createDatabase($this->tenant);
event(new DatabaseCreated($this->tenant));

29
src/Jobs/DeleteDomains.php Normal file
View file

@ -0,0 +1,29 @@
<?php
declare(strict_types=1);
namespace Stancl\Tenancy\Jobs;
use Illuminate\Bus\Queueable;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Stancl\Tenancy\Contracts\TenantWithDatabase;
class DeleteDomains
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/** @var TenantWithDatabase */
protected $tenant;
public function __construct(TenantWithDatabase $tenant)
{
$this->tenant = $tenant;
}
public function handle()
{
$this->tenant->domains->each->delete();
}
}

3
src/Listeners/UpdateSyncedResource.php
View file

@ -48,8 +48,7 @@ class UpdateSyncedResource extends QueueableListener
protected function updateResourceInCentralDatabaseAndGetTenants($event, $syncedAttributes)
{
/** @var Model|SyncMaster $centralModel */
$centralModel = $event->model->getCentralModelName()
::where($event->model->getGlobalIdentifierKeyName(), $event->model->getGlobalIdentifierKey())
$centralModel = $event->model->getCentralModelName()::where($event->model->getGlobalIdentifierKeyName(), $event->model->getGlobalIdentifierKey())
->first();
// We disable events for this call, to avoid triggering this event & listener again.

9
src/Middleware/CheckTenantForMaintenanceMode.php
View file

@ -5,10 +5,10 @@ declare(strict_types=1);
namespace Stancl\Tenancy\Middleware;
use Closure;
use Illuminate\Foundation\Http\Exceptions\MaintenanceModeException;
use Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode;
use Stancl\Tenancy\Exceptions\TenancyNotInitializedException;
use Symfony\Component\HttpFoundation\IpUtils;
use Symfony\Component\HttpKernel\Exception\HttpException;
class CheckTenantForMaintenanceMode extends CheckForMaintenanceMode
{
@ -29,7 +29,12 @@ class CheckTenantForMaintenanceMode extends CheckForMaintenanceMode
return $next($request);
}
throw new MaintenanceModeException($data['time'], $data['retry'], $data['message']);
throw new HttpException(
503,
'Service Unavailable',
null,
isset($data['retry']) ? ['Retry-After' => $data['retry']] : []
);
}
return $next($request);

6
src/Middleware/InitializeTenancyByDomain.php
View file

@ -29,13 +29,13 @@ class InitializeTenancyByDomain extends IdentificationMiddleware
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
return $this->initializeTenancy(
$request, $next, $request->getHost()
$request,
$next,
$request->getHost()
);
}
}

2
src/Middleware/InitializeTenancyByDomainOrSubdomain.php
View file

@ -13,8 +13,6 @@ class InitializeTenancyByDomainOrSubdomain
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{

4
src/Middleware/InitializeTenancyByPath.php
View file

@ -38,7 +38,9 @@ class InitializeTenancyByPath extends IdentificationMiddleware
// simply injected into some route controller action.
if ($route->parameterNames()[0] === PathTenantResolver::$tenantParameterName) {
return $this->initializeTenancy(
$request, $next, $route
$request,
$next,
$route
);
} else {
throw new RouteIsMissingTenantParameterException;

2
src/Middleware/InitializeTenancyByRequestData.php
View file

@ -36,8 +36,6 @@ class InitializeTenancyByRequestData extends IdentificationMiddleware
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{

2
src/Middleware/InitializeTenancyBySubdomain.php
View file

@ -28,8 +28,6 @@ class InitializeTenancyBySubdomain extends InitializeTenancyByDomain
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{

1
src/Resolvers/Contracts/CachedTenantResolver.php
View file

@ -75,7 +75,6 @@ abstract class CachedTenantResolver implements TenantResolver
/**
* Get all the arg combinations for resolve() that can be used to find this tenant.
*
* @param Tenant $tenant
* @return array[]
*/
abstract public function getArgsForTenant(Tenant $tenant): array;

9
src/Tenancy.php
View file

@ -27,7 +27,6 @@ class Tenancy
/**
* Initializes the tenant.
* @param Tenant|int|string $tenant
* @return void
*/
public function initialize($tenant): void
{
@ -66,10 +65,10 @@ class Tenancy
return;
}
$this->initialized = false;
event(new Events\TenancyEnded($this));
$this->initialized = false;
$this->tenant = null;
}
@ -106,9 +105,6 @@ class Tenancy
/**
* Run a callback in the central context.
* Atomic, safely reverts to previous context.
*
* @param callable $callback
* @return mixed
*/
public function central(callable $callback)
{
@ -132,7 +128,6 @@ class Tenancy
* More performant than running $tenant->run() one by one.
*
* @param Tenant[]|\Traversable|string[]|null $tenants
* @param callable $callback
* @return void
*/
public function runForMultiple($tenants, callable $callback)

6
src/TenancyServiceProvider.php
View file

@ -7,6 +7,7 @@ namespace Stancl\Tenancy;
use Illuminate\Cache\CacheManager;
use Illuminate\Support\ServiceProvider;
use Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper;
use Stancl\Tenancy\Contracts\Domain;
use Stancl\Tenancy\Contracts\Tenant;
use Stancl\Tenancy\Resolvers\DomainTenantResolver;
@ -14,8 +15,6 @@ class TenancyServiceProvider extends ServiceProvider
{
/**
* Register services.
*
* @return void
*/
public function register(): void
{
@ -75,8 +74,6 @@ class TenancyServiceProvider extends ServiceProvider
/**
* Bootstrap services.
*
* @return void
*/
public function boot(): void
{
@ -88,6 +85,7 @@ class TenancyServiceProvider extends ServiceProvider
Commands\Migrate::class,
Commands\Rollback::class,
Commands\TenantList::class,
Commands\TenantDump::class,
Commands\MigrateFresh::class,
]);

57
src/TenantDatabaseManagers/MicrosoftSQLDatabaseManager.php Normal file
View file

@ -0,0 +1,57 @@
<?php
declare(strict_types=1);
namespace Stancl\Tenancy\TenantDatabaseManagers;
use Illuminate\Database\Connection;
use Illuminate\Support\Facades\DB;
use Stancl\Tenancy\Contracts\TenantDatabaseManager;
use Stancl\Tenancy\Contracts\TenantWithDatabase;
use Stancl\Tenancy\Exceptions\NoConnectionSetException;
class MicrosoftSQLDatabaseManager implements TenantDatabaseManager
{
/** @var string */
protected $connection;
protected function database(): Connection
{
if ($this->connection === null) {
throw new NoConnectionSetException(static::class);
}
return DB::connection($this->connection);
}
public function setConnection(string $connection): void
{
$this->connection = $connection;
}
public function createDatabase(TenantWithDatabase $tenant): bool
{
$database = $tenant->database()->getName();
$charset = $this->database()->getConfig('charset');
$collation = $this->database()->getConfig('collation');
return $this->database()->statement("CREATE DATABASE [{$database}]");
}
public function deleteDatabase(TenantWithDatabase $tenant): bool
{
return $this->database()->statement("DROP DATABASE [{$tenant->database()->getName()}]");
}
public function databaseExists(string $name): bool
{
return (bool) $this->database()->select("SELECT name FROM master.sys.databases WHERE name = '$name'");
}
public function makeConnectionConfig(array $baseConfig, string $databaseName): array
{
$baseConfig['database'] = $databaseName;
return $baseConfig;
}
}

5
src/TenantDatabaseManagers/PermissionControlledMySQLDatabaseManager.php
View file

@ -7,7 +7,6 @@ namespace Stancl\Tenancy\TenantDatabaseManagers;
use Stancl\Tenancy\Concerns\CreatesDatabaseUsers;
use Stancl\Tenancy\Contracts\ManagesDatabaseUsers;
use Stancl\Tenancy\DatabaseConfig;
use Stancl\Tenancy\Exceptions\TenantDatabaseUserAlreadyExistsException;
class PermissionControlledMySQLDatabaseManager extends MySQLDatabaseManager implements ManagesDatabaseUsers
{
@ -26,10 +25,6 @@ class PermissionControlledMySQLDatabaseManager extends MySQLDatabaseManager impl
$hostname = $databaseConfig->connection()['host'];
$password = $databaseConfig->getPassword();
if ($this->userExists($username)) {
throw new TenantDatabaseUserAlreadyExistsException($username);
}
$this->database()->statement("CREATE USER `{$username}`@`%` IDENTIFIED BY '{$password}'");
$grants = implode(', ', static::$grants);

6
src/TenantDatabaseManagers/PostgreSQLSchemaManager.php
View file

@ -46,7 +46,11 @@ class PostgreSQLSchemaManager implements TenantDatabaseManager
public function makeConnectionConfig(array $baseConfig, string $databaseName): array
{
$baseConfig['schema'] = $databaseName;
if (version_compare(app()->version(), '9.0', '>=')) {
$baseConfig['search_path'] = $databaseName;
} else {
$baseConfig['schema'] = $databaseName;
}
return $baseConfig;
}

2
test
View file

@ -1,3 +1,3 @@
#!/bin/bash
docker-compose exec -T test vendor/bin/phpunit "$@"
docker-compose exec -T test vendor/bin/pest "$@"

194
tests/AutomaticModeTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Event;
use Stancl\Tenancy\Contracts\TenancyBootstrapper;
use Stancl\Tenancy\Events\TenancyEnded;
@ -12,113 +10,99 @@ use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\Tests\Etc\Tenant;
class AutomaticModeTest extends TestCase
beforeEach(function () {
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
});
test('context is switched when tenancy is initialized', function () {
contextIsSwitchedWhenTenancyInitialized();
});
test('context is reverted when tenancy is ended', function () {
contextIsSwitchedWhenTenancyInitialized();
tenancy()->end();
expect(app('tenancy_ended'))->toBe(true);
});
test('context is switched when tenancy is reinitialized', function () {
config(['tenancy.bootstrappers' => [
MyBootstrapper::class,
]]);
$tenant = Tenant::create([
'id' => 'acme',
]);
tenancy()->initialize($tenant);
expect(app('tenancy_initialized_for_tenant'))->toBe('acme');
$tenant2 = Tenant::create([
'id' => 'foobar',
]);
tenancy()->initialize($tenant2);
expect(app('tenancy_initialized_for_tenant'))->toBe('foobar');
});
test('central helper runs callbacks in the central state', function () {
tenancy()->initialize($tenant = Tenant::create());
tenancy()->central(function () {
expect(tenant())->toBe(null);
});
expect(tenant())->toBe($tenant);
});
test('central helper returns the value from the callback', function () {
tenancy()->initialize(Tenant::create());
pest()->assertSame('foo', tenancy()->central(function () {
return 'foo';
}));
});
test('central helper reverts back to tenant context', function () {
tenancy()->initialize($tenant = Tenant::create());
tenancy()->central(function () {
//
});
expect(tenant())->toBe($tenant);
});
test('central helper doesnt change tenancy state when called in central context', function () {
expect(tenancy()->initialized)->toBeFalse();
expect(tenant())->toBeNull();
tenancy()->central(function () {
//
});
expect(tenancy()->initialized)->toBeFalse();
expect(tenant())->toBeNull();
});
// todo@tests
function contextIsSwitchedWhenTenancyInitialized()
{
public function setUp(): void
{
parent::setUp();
config(['tenancy.bootstrappers' => [
MyBootstrapper::class,
]]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
}
$tenant = Tenant::create([
'id' => 'acme',
]);
/** @test */
public function context_is_switched_when_tenancy_is_initialized()
{
config(['tenancy.bootstrappers' => [
MyBootstrapper::class,
]]);
tenancy()->initialize($tenant);
$tenant = Tenant::create([
'id' => 'acme',
]);
tenancy()->initialize($tenant);
$this->assertSame('acme', app('tenancy_initialized_for_tenant'));
}
/** @test */
public function context_is_reverted_when_tenancy_is_ended()
{
$this->context_is_switched_when_tenancy_is_initialized();
tenancy()->end();
$this->assertSame(true, app('tenancy_ended'));
}
/** @test */
public function context_is_switched_when_tenancy_is_reinitialized()
{
config(['tenancy.bootstrappers' => [
MyBootstrapper::class,
]]);
$tenant = Tenant::create([
'id' => 'acme',
]);
tenancy()->initialize($tenant);
$this->assertSame('acme', app('tenancy_initialized_for_tenant'));
$tenant2 = Tenant::create([
'id' => 'foobar',
]);
tenancy()->initialize($tenant2);
$this->assertSame('foobar', app('tenancy_initialized_for_tenant'));
}
/** @test */
public function central_helper_runs_callbacks_in_the_central_state()
{
tenancy()->initialize($tenant = Tenant::create());
tenancy()->central(function () {
$this->assertSame(null, tenant());
});
$this->assertSame($tenant, tenant());
}
/** @test */
public function central_helper_returns_the_value_from_the_callback()
{
tenancy()->initialize(Tenant::create());
$this->assertSame('foo', tenancy()->central(function () {
return 'foo';
}));
}
/** @test */
public function central_helper_reverts_back_to_tenant_context()
{
tenancy()->initialize($tenant = Tenant::create());
tenancy()->central(function () {
//
});
$this->assertSame($tenant, tenant());
}
/** @test */
public function central_helper_doesnt_change_tenancy_state_when_called_in_central_context()
{
$this->assertFalse(tenancy()->initialized);
$this->assertNull(tenant());
tenancy()->central(function () {
//
});
$this->assertFalse(tenancy()->initialized);
$this->assertNull(tenant());
}
expect(app('tenancy_initialized_for_tenant'))->toBe('acme');
}
class MyBootstrapper implements TenancyBootstrapper

457
tests/BootstrapperTest.php
View file

@ -2,18 +2,15 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Cache;
use Illuminate\Filesystem\FilesystemAdapter;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\DB;
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Redis;
use Illuminate\Support\Facades\Storage;
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
use Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper;
use Stancl\Tenancy\Bootstrappers\RedisTenancyBootstrapper;
use Stancl\Tenancy\Events\TenancyEnded;
use Stancl\Tenancy\Events\TenancyInitialized;
use Stancl\Tenancy\Events\TenantCreated;
@ -23,263 +20,255 @@ use Stancl\Tenancy\Jobs\CreateStorageSymlinks;
use Stancl\Tenancy\Jobs\RemoveStorageSymlinks;
use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
use Stancl\Tenancy\Bootstrappers\RedisTenancyBootstrapper;
use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
use Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper;
class BootstrapperTest extends TestCase
{
public $mockConsoleOutput = false;
beforeEach(function () {
$this->mockConsoleOutput = false;
public function setUp(): void
{
parent::setUp();
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
});
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
test('database data is separated', function () {
config(['tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
]]);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
pest()->artisan('tenants:migrate');
tenancy()->initialize($tenant1);
// Create Foo user
DB::table('users')->insert(['name' => 'Foo', 'email' => 'foo@bar.com', 'password' => 'secret']);
expect(DB::table('users')->get())->toHaveCount(1);
tenancy()->initialize($tenant2);
// Assert Foo user is not in this DB
expect(DB::table('users')->get())->toHaveCount(0);
// Create Bar user
DB::table('users')->insert(['name' => 'Bar', 'email' => 'bar@bar.com', 'password' => 'secret']);
expect(DB::table('users')->get())->toHaveCount(1);
tenancy()->initialize($tenant1);
// Assert Bar user is not in this DB
expect(DB::table('users')->get())->toHaveCount(1);
expect(DB::table('users')->first()->name)->toBe('Foo');
});
test('cache data is separated', function () {
config([
'tenancy.bootstrappers' => [
CacheTenancyBootstrapper::class,
],
'cache.default' => 'redis',
]);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
cache()->set('foo', 'central');
expect(Cache::get('foo'))->toBe('central');
tenancy()->initialize($tenant1);
// Assert central cache doesn't leak to tenant context
expect(Cache::has('foo'))->toBeFalse();
cache()->set('foo', 'bar');
expect(Cache::get('foo'))->toBe('bar');
tenancy()->initialize($tenant2);
// Assert one tenant's data doesn't leak to another tenant
expect(Cache::has('foo'))->toBeFalse();
cache()->set('foo', 'xyz');
expect(Cache::get('foo'))->toBe('xyz');
tenancy()->initialize($tenant1);
// Asset data didn't leak to original tenant
expect(Cache::get('foo'))->toBe('bar');
tenancy()->end();
// Asset central is still the same
expect(Cache::get('foo'))->toBe('central');
});
test('redis data is separated', function () {
config(['tenancy.bootstrappers' => [
RedisTenancyBootstrapper::class,
]]);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
tenancy()->initialize($tenant1);
Redis::set('foo', 'bar');
expect(Redis::get('foo'))->toBe('bar');
tenancy()->initialize($tenant2);
expect(Redis::get('foo'))->toBe(null);
Redis::set('foo', 'xyz');
Redis::set('abc', 'def');
expect(Redis::get('foo'))->toBe('xyz');
expect(Redis::get('abc'))->toBe('def');
tenancy()->initialize($tenant1);
expect(Redis::get('foo'))->toBe('bar');
expect(Redis::get('abc'))->toBe(null);
$tenant3 = Tenant::create();
tenancy()->initialize($tenant3);
expect(Redis::get('foo'))->toBe(null);
expect(Redis::get('abc'))->toBe(null);
});
test('filesystem data is separated', function () {
config(['tenancy.bootstrappers' => [
FilesystemTenancyBootstrapper::class,
]]);
$old_storage_path = storage_path();
$old_storage_facade_roots = [];
foreach (config('tenancy.filesystem.disks') as $disk) {
$old_storage_facade_roots[$disk] = config("filesystems.disks.{$disk}.root");
}
/** @test */
public function database_data_is_separated()
{
config(['tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
]]);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
tenancy()->initialize($tenant1);
$this->artisan('tenants:migrate');
Storage::disk('public')->put('foo', 'bar');
expect(Storage::disk('public')->get('foo'))->toBe('bar');
tenancy()->initialize($tenant1);
tenancy()->initialize($tenant2);
expect(Storage::disk('public')->exists('foo'))->toBeFalse();
Storage::disk('public')->put('foo', 'xyz');
Storage::disk('public')->put('abc', 'def');
expect(Storage::disk('public')->get('foo'))->toBe('xyz');
expect(Storage::disk('public')->get('abc'))->toBe('def');
// Create Foo user
DB::table('users')->insert(['name' => 'Foo', 'email' => 'foo@bar.com', 'password' => 'secret']);
$this->assertCount(1, DB::table('users')->get());
tenancy()->initialize($tenant1);
expect(Storage::disk('public')->get('foo'))->toBe('bar');
expect(Storage::disk('public')->exists('abc'))->toBeFalse();
tenancy()->initialize($tenant2);
$tenant3 = Tenant::create();
tenancy()->initialize($tenant3);
expect(Storage::disk('public')->exists('foo'))->toBeFalse();
expect(Storage::disk('public')->exists('abc'))->toBeFalse();
// Assert Foo user is not in this DB
$this->assertCount(0, DB::table('users')->get());
// Create Bar user
DB::table('users')->insert(['name' => 'Bar', 'email' => 'bar@bar.com', 'password' => 'secret']);
$this->assertCount(1, DB::table('users')->get());
$expected_storage_path = $old_storage_path . '/tenant' . tenant('id'); // /tenant = suffix base
tenancy()->initialize($tenant1);
// Check that disk prefixes respect the root_override logic
expect(getDiskPrefix('local'))->toBe($expected_storage_path . '/app/');
expect(getDiskPrefix('public'))->toBe($expected_storage_path . '/app/public/');
pest()->assertSame('tenant' . tenant('id') . '/', getDiskPrefix('s3'), '/');
// Assert Bar user is not in this DB
$this->assertCount(1, DB::table('users')->get());
$this->assertSame('Foo', DB::table('users')->first()->name);
}
// Check suffixing logic
$new_storage_path = storage_path();
expect($new_storage_path)->toEqual($expected_storage_path);
});
/** @test */
public function cache_data_is_separated()
{
config([
'tenancy.bootstrappers' => [
CacheTenancyBootstrapper::class,
],
'cache.default' => 'redis',
]);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
cache()->set('foo', 'central');
$this->assertSame('central', Cache::get('foo'));
tenancy()->initialize($tenant1);
// Assert central cache doesn't leak to tenant context
$this->assertFalse(Cache::has('foo'));
cache()->set('foo', 'bar');
$this->assertSame('bar', Cache::get('foo'));
tenancy()->initialize($tenant2);
// Assert one tenant's data doesn't leak to another tenant
$this->assertFalse(Cache::has('foo'));
cache()->set('foo', 'xyz');
$this->assertSame('xyz', Cache::get('foo'));
tenancy()->initialize($tenant1);
// Asset data didn't leak to original tenant
$this->assertSame('bar', Cache::get('foo'));
tenancy()->end();
// Asset central is still the same
$this->assertSame('central', Cache::get('foo'));
}
/** @test */
public function redis_data_is_separated()
{
config(['tenancy.bootstrappers' => [
RedisTenancyBootstrapper::class,
]]);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
tenancy()->initialize($tenant1);
Redis::set('foo', 'bar');
$this->assertSame('bar', Redis::get('foo'));
tenancy()->initialize($tenant2);
$this->assertSame(null, Redis::get('foo'));
Redis::set('foo', 'xyz');
Redis::set('abc', 'def');
$this->assertSame('xyz', Redis::get('foo'));
$this->assertSame('def', Redis::get('abc'));
tenancy()->initialize($tenant1);
$this->assertSame('bar', Redis::get('foo'));
$this->assertSame(null, Redis::get('abc'));
$tenant3 = Tenant::create();
tenancy()->initialize($tenant3);
$this->assertSame(null, Redis::get('foo'));
$this->assertSame(null, Redis::get('abc'));
}
/** @test */
public function filesystem_data_is_separated()
{
config(['tenancy.bootstrappers' => [
test('filesystem local storage has own public url', function() {
config([
'tenancy.bootstrappers' => [
FilesystemTenancyBootstrapper::class,
]]);
],
'tenancy.filesystem.root_override.public' => '%storage_path%/app/public/',
'tenancy.filesystem.url_override.public' => 'public-%tenant_id%'
]);
$old_storage_path = storage_path();
$old_storage_facade_roots = [];
foreach (config('tenancy.filesystem.disks') as $disk) {
$old_storage_facade_roots[$disk] = config("filesystems.disks.{$disk}.root");
}
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
tenancy()->initialize($tenant1);
$this->assertEquals(
'http://localhost/public-'.$tenant1->getTenantKey().'/',
Storage::disk('public')->url('')
);
tenancy()->initialize($tenant1);
Storage::disk('public')->put('foo', 'bar');
$this->assertSame('bar', Storage::disk('public')->get('foo'));
tenancy()->initialize($tenant2);
$this->assertEquals(
'http://localhost/public-'.$tenant2->getTenantKey().'/',
Storage::disk('public')->url('')
);
});
tenancy()->initialize($tenant2);
$this->assertFalse(Storage::disk('public')->exists('foo'));
Storage::disk('public')->put('foo', 'xyz');
Storage::disk('public')->put('abc', 'def');
$this->assertSame('xyz', Storage::disk('public')->get('foo'));
$this->assertSame('def', Storage::disk('public')->get('abc'));
test('create and delete storage symlinks jobs works', function() {
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateStorageSymlinks::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
tenancy()->initialize($tenant1);
$this->assertSame('bar', Storage::disk('public')->get('foo'));
$this->assertFalse(Storage::disk('public')->exists('abc'));
Event::listen(
TenantDeleted::class,
JobPipeline::make([RemoveStorageSymlinks::class])->send(function (TenantDeleted $event) {
return $event->tenant;
})->toListener()
);
$tenant3 = Tenant::create();
tenancy()->initialize($tenant3);
$this->assertFalse(Storage::disk('public')->exists('foo'));
$this->assertFalse(Storage::disk('public')->exists('abc'));
config([
'tenancy.bootstrappers' => [
FilesystemTenancyBootstrapper::class,
],
'tenancy.filesystem.suffix_base' => 'tenant-',
'tenancy.filesystem.root_override.public' => '%storage_path%/app/public/',
'tenancy.filesystem.url_override.public' => 'public-%tenant_id%'
]);
// Check suffixing logic
$new_storage_path = storage_path();
$this->assertEquals($old_storage_path . '/' . config('tenancy.filesystem.suffix_base') . tenant('id'), $new_storage_path);
/** @var \Stancl\Tenancy\Database\Models\Tenant $tenant */
$tenant = Tenant::create();
foreach (config('tenancy.filesystem.disks') as $disk) {
$suffix = config('tenancy.filesystem.suffix_base') . tenant('id');
tenancy()->initialize($tenant);
/** @var FilesystemAdapter $filesystemDisk */
$filesystemDisk = Storage::disk($disk);
$tenant_key = $tenant->getTenantKey();
$current_path_prefix = $filesystemDisk->getAdapter()->getPathPrefix();
$this->assertDirectoryExists(storage_path("app/public"));
$this->assertEquals(storage_path("app/public/"), readlink(public_path("public-$tenant_key")));
if ($override = config("tenancy.filesystem.root_override.{$disk}")) {
$correct_path_prefix = str_replace('%storage_path%', storage_path(), $override);
} else {
if ($base = $old_storage_facade_roots[$disk]) {
$correct_path_prefix = $base . "/$suffix/";
} else {
$correct_path_prefix = "$suffix/";
}
}
$tenant->delete();
$this->assertSame($correct_path_prefix, $current_path_prefix);
}
$this->assertDirectoryDoesNotExist(public_path("public-$tenant_key"));
});
function getDiskPrefix(string $disk): string
{
/** @var FilesystemAdapter $disk */
$disk = Storage::disk($disk);
$adapter = $disk->getAdapter();
if (! Str::startsWith(app()->version(), '9.')) {
return $adapter->getPathPrefix();
}
/** @test */
public function filesystem_local_storage_has_own_public_url()
{
config([
'tenancy.bootstrappers' => [
FilesystemTenancyBootstrapper::class,
],
'tenancy.filesystem.root_override.public' => '%storage_path%/app/public/',
'tenancy.filesystem.url_override.public' => 'public-%tenant_id%'
]);
$prefixer = (new ReflectionObject($adapter))->getProperty('prefixer');
$prefixer->setAccessible(true);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
// reflection -> instance
$prefixer = $prefixer->getValue($adapter);
tenancy()->initialize($tenant1);
$this->assertEquals(
'http://localhost/public-'.$tenant1->getTenantKey().'/',
Storage::disk('public')->url('')
);
$prefix = (new ReflectionProperty($prefixer, 'prefix'));
$prefix->setAccessible(true);
tenancy()->initialize($tenant2);
$this->assertEquals(
'http://localhost/public-'.$tenant2->getTenantKey().'/',
Storage::disk('public')->url('')
);
}
/** @test */
public function create_and_delete_storage_symlinks_jobs_works()
{
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateStorageSymlinks::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(
TenantDeleted::class,
JobPipeline::make([RemoveStorageSymlinks::class])->send(function (TenantDeleted $event) {
return $event->tenant;
})->toListener()
);
config([
'tenancy.bootstrappers' => [
FilesystemTenancyBootstrapper::class,
],
'tenancy.filesystem.suffix_base' => 'tenant-',
'tenancy.filesystem.root_override.public' => '%storage_path%/app/public/',
'tenancy.filesystem.url_override.public' => 'public-%tenant_id%'
]);
/** @var \Stancl\Tenancy\Database\Models\Tenant $tenant */
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$tenant_key = $tenant->getTenantKey();
$this->assertDirectoryExists(storage_path("app/public"));
$this->assertEquals(storage_path("app/public/"), readlink(public_path("public-$tenant_key")));
$tenant->delete();
$this->assertDirectoryDoesNotExist(public_path("public-$tenant_key"));
}
// for queues see QueueTest
return $prefix->getValue($prefixer);
}

170
tests/CacheManagerTest.php
View file

@ -2,136 +2,110 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Event;
use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
use Stancl\Tenancy\Events\TenancyInitialized;
use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Tests\Etc\Tenant;
class CacheManagerTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
beforeEach(function () {
config(['tenancy.bootstrappers' => [
CacheTenancyBootstrapper::class,
]]);
config(['tenancy.bootstrappers' => [
CacheTenancyBootstrapper::class,
]]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
});
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
}
test('default tag is automatically applied', function () {
tenancy()->initialize(Tenant::create());
/** @test */
public function default_tag_is_automatically_applied()
{
tenancy()->initialize(Tenant::create());
pest()->assertArrayIsSubset([config('tenancy.cache.tag_base') . tenant('id')], cache()->tags('foo')->getTags()->getNames());
});
$this->assertArrayIsSubset([config('tenancy.cache.tag_base') . tenant('id')], cache()->tags('foo')->getTags()->getNames());
}
test('tags are merged when array is passed', function () {
tenancy()->initialize(Tenant::create());
/** @test */
public function tags_are_merged_when_array_is_passed()
{
tenancy()->initialize(Tenant::create());
$expected = [config('tenancy.cache.tag_base') . tenant('id'), 'foo', 'bar'];
expect(cache()->tags(['foo', 'bar'])->getTags()->getNames())->toEqual($expected);
});
$expected = [config('tenancy.cache.tag_base') . tenant('id'), 'foo', 'bar'];
$this->assertEquals($expected, cache()->tags(['foo', 'bar'])->getTags()->getNames());
}
test('tags are merged when string is passed', function () {
tenancy()->initialize(Tenant::create());
/** @test */
public function tags_are_merged_when_string_is_passed()
{
tenancy()->initialize(Tenant::create());
$expected = [config('tenancy.cache.tag_base') . tenant('id'), 'foo'];
expect(cache()->tags('foo')->getTags()->getNames())->toEqual($expected);
});
$expected = [config('tenancy.cache.tag_base') . tenant('id'), 'foo'];
$this->assertEquals($expected, cache()->tags('foo')->getTags()->getNames());
}
test('exception is thrown when zero arguments are passed to tags method', function () {
tenancy()->initialize(Tenant::create());
/** @test */
public function exception_is_thrown_when_zero_arguments_are_passed_to_tags_method()
{
tenancy()->initialize(Tenant::create());
pest()->expectException(\Exception::class);
cache()->tags();
});
$this->expectException(\Exception::class);
cache()->tags();
}
test('exception is thrown when more than one argument is passed to tags method', function () {
tenancy()->initialize(Tenant::create());
/** @test */
public function exception_is_thrown_when_more_than_one_argument_is_passed_to_tags_method()
{
tenancy()->initialize(Tenant::create());
pest()->expectException(\Exception::class);
cache()->tags(1, 2);
});
$this->expectException(\Exception::class);
cache()->tags(1, 2);
}
test('tags separate cache well enough', function () {
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
/** @test */
public function tags_separate_cache_well_enough()
{
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
cache()->put('foo', 'bar', 1);
expect(cache()->get('foo'))->toBe('bar');
cache()->put('foo', 'bar', 1);
$this->assertSame('bar', cache()->get('foo'));
$tenant2 = Tenant::create();
tenancy()->initialize($tenant2);
$tenant2 = Tenant::create();
tenancy()->initialize($tenant2);
pest()->assertNotSame('bar', cache()->get('foo'));
$this->assertNotSame('bar', cache()->get('foo'));
cache()->put('foo', 'xyz', 1);
expect(cache()->get('foo'))->toBe('xyz');
});
cache()->put('foo', 'xyz', 1);
$this->assertSame('xyz', cache()->get('foo'));
}
test('invoking the cache helper works', function () {
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
/** @test */
public function invoking_the_cache_helper_works()
{
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
cache(['foo' => 'bar'], 1);
expect(cache('foo'))->toBe('bar');
cache(['foo' => 'bar'], 1);
$this->assertSame('bar', cache('foo'));
$tenant2 = Tenant::create();
tenancy()->initialize($tenant2);
$tenant2 = Tenant::create();
tenancy()->initialize($tenant2);
pest()->assertNotSame('bar', cache('foo'));
$this->assertNotSame('bar', cache('foo'));
cache(['foo' => 'xyz'], 1);
expect(cache('foo'))->toBe('xyz');
});
cache(['foo' => 'xyz'], 1);
$this->assertSame('xyz', cache('foo'));
}
test('cache is persisted', function () {
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
/** @test */
public function cache_is_persisted()
{
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
cache(['foo' => 'bar'], 10);
expect(cache('foo'))->toBe('bar');
cache(['foo' => 'bar'], 10);
$this->assertSame('bar', cache('foo'));
tenancy()->end();
tenancy()->end();
tenancy()->initialize($tenant1);
expect(cache('foo'))->toBe('bar');
});
tenancy()->initialize($tenant1);
$this->assertSame('bar', cache('foo'));
}
test('cache is persisted when reidentification is used', function () {
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
tenancy()->initialize($tenant1);
/** @test */
public function cache_is_persisted_when_reidentification_is_used()
{
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
tenancy()->initialize($tenant1);
cache(['foo' => 'bar'], 10);
expect(cache('foo'))->toBe('bar');
cache(['foo' => 'bar'], 10);
$this->assertSame('bar', cache('foo'));
tenancy()->initialize($tenant2);
tenancy()->end();
tenancy()->initialize($tenant2);
tenancy()->end();
tenancy()->initialize($tenant1);
$this->assertSame('bar', cache('foo'));
}
}
tenancy()->initialize($tenant1);
expect(cache('foo'))->toBe('bar');
});

149
tests/CachedTenantResolverTest.php
View file

@ -2,111 +2,94 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\DB;
use Stancl\Tenancy\Resolvers\DomainTenantResolver;
use Stancl\Tenancy\Tests\Etc\Tenant;
class CachedTenantResolverTest extends TestCase
{
public function tearDown(): void
{
DomainTenantResolver::$shouldCache = false;
afterEach(function () {
DomainTenantResolver::$shouldCache = false;
});
parent::tearDown();
}
test('tenants can be resolved using the cached resolver', function () {
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'acme',
]);
/** @test */
public function tenants_can_be_resolved_using_the_cached_resolver()
{
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'acme',
]);
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue()->toBeTrue();
});
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
}
test('the underlying resolver is not touched when using the cached resolver', function () {
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'acme',
]);
/** @test */
public function the_underlying_resolver_is_not_touched_when_using_the_cached_resolver()
{
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'acme',
]);
DB::enableQueryLog();
DB::enableQueryLog();
DomainTenantResolver::$shouldCache = false;
DomainTenantResolver::$shouldCache = false;
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
DB::flushQueryLog();
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
pest()->assertNotEmpty(DB::getQueryLog()); // not empty
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
DB::flushQueryLog();
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
$this->assertNotEmpty(DB::getQueryLog()); // not empty
DomainTenantResolver::$shouldCache = true;
DomainTenantResolver::$shouldCache = true;
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
DB::flushQueryLog();
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
expect(DB::getQueryLog())->toBeEmpty(); // empty
});
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
DB::flushQueryLog();
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
$this->assertEmpty(DB::getQueryLog()); // empty
}
test('cache is invalidated when the tenant is updated', function () {
$tenant = Tenant::create();
$tenant->createDomain([
'domain' => 'acme',
]);
/** @test */
public function cache_is_invalidated_when_the_tenant_is_updated()
{
$tenant = Tenant::create();
$tenant->createDomain([
'domain' => 'acme',
]);
DB::enableQueryLog();
DB::enableQueryLog();
DomainTenantResolver::$shouldCache = true;
DomainTenantResolver::$shouldCache = true;
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
DB::flushQueryLog();
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
expect(DB::getQueryLog())->toBeEmpty(); // empty
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
DB::flushQueryLog();
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
$this->assertEmpty(DB::getQueryLog()); // empty
$tenant->update([
'foo' => 'bar',
]);
$tenant->update([
'foo' => 'bar',
]);
DB::flushQueryLog();
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
pest()->assertNotEmpty(DB::getQueryLog()); // not empty
});
DB::flushQueryLog();
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
$this->assertNotEmpty(DB::getQueryLog()); // not empty
}
test('cache is invalidated when a tenants domain is changed', function () {
$tenant = Tenant::create();
$tenant->createDomain([
'domain' => 'acme',
]);
/** @test */
public function cache_is_invalidated_when_a_tenants_domain_is_changed()
{
$tenant = Tenant::create();
$tenant->createDomain([
'domain' => 'acme',
]);
DB::enableQueryLog();
DB::enableQueryLog();
DomainTenantResolver::$shouldCache = true;
DomainTenantResolver::$shouldCache = true;
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
DB::flushQueryLog();
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
expect(DB::getQueryLog())->toBeEmpty(); // empty
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
DB::flushQueryLog();
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
$this->assertEmpty(DB::getQueryLog()); // empty
$tenant->createDomain([
'domain' => 'bar',
]);
$tenant->createDomain([
'domain' => 'bar',
]);
DB::flushQueryLog();
expect($tenant->is(app(DomainTenantResolver::class)->resolve('acme')))->toBeTrue();
pest()->assertNotEmpty(DB::getQueryLog()); // not empty
DB::flushQueryLog();
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('acme')));
$this->assertNotEmpty(DB::getQueryLog()); // not empty
DB::flushQueryLog();
$this->assertTrue($tenant->is(app(DomainTenantResolver::class)->resolve('bar')));
$this->assertNotEmpty(DB::getQueryLog()); // not empty
}
}
DB::flushQueryLog();
expect($tenant->is(app(DomainTenantResolver::class)->resolve('bar')))->toBeTrue();
pest()->assertNotEmpty(DB::getQueryLog()); // not empty
});

92
tests/CombinedDomainAndSubdomainIdentificationTest.php
View file

@ -2,76 +2,64 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Database\Concerns\HasDomains;
use Stancl\Tenancy\Database\Models;
use Stancl\Tenancy\Middleware\InitializeTenancyByDomainOrSubdomain;
use Stancl\Tenancy\Database\Models;
class CombinedDomainAndSubdomainIdentificationTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
Route::group([
'middleware' => InitializeTenancyByDomainOrSubdomain::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
beforeEach(function () {
Route::group([
'middleware' => InitializeTenancyByDomainOrSubdomain::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
});
config(['tenancy.tenant_model' => CombinedTenant::class]);
}
config(['tenancy.tenant_model' => CombinedTenant::class]);
});
/** @test */
public function tenant_can_be_identified_by_subdomain()
{
config(['tenancy.central_domains' => ['localhost']]);
test('tenant can be identified by subdomain', function () {
config(['tenancy.central_domains' => ['localhost']]);
$tenant = CombinedTenant::create([
'id' => 'acme',
]);
$tenant = CombinedTenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'foo',
]);
$tenant->domains()->create([
'domain' => 'foo',
]);
$this->assertFalse(tenancy()->initialized);
expect(tenancy()->initialized)->toBeFalse();
$this
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
pest()
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
$this->assertTrue(tenancy()->initialized);
$this->assertSame('acme', tenant('id'));
}
expect(tenancy()->initialized)->toBeTrue();
expect(tenant('id'))->toBe('acme');
});
/** @test */
public function tenant_can_be_identified_by_domain()
{
config(['tenancy.central_domains' => []]);
test('tenant can be identified by domain', function () {
config(['tenancy.central_domains' => []]);
$tenant = CombinedTenant::create([
'id' => 'acme',
]);
$tenant = CombinedTenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'foobar.localhost',
]);
$tenant->domains()->create([
'domain' => 'foobar.localhost',
]);
$this->assertFalse(tenancy()->initialized);
expect(tenancy()->initialized)->toBeFalse();
$this
->get('http://foobar.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
pest()
->get('http://foobar.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
$this->assertTrue(tenancy()->initialized);
$this->assertSame('acme', tenant('id'));
}
}
expect(tenancy()->initialized)->toBeTrue();
expect(tenant('id'))->toBe('acme');
});
class CombinedTenant extends Models\Tenant
{

388
tests/CommandsTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Event;
@ -19,231 +17,205 @@ use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\Tests\Etc\ExampleSeeder;
use Stancl\Tenancy\Tests\Etc\Tenant;
class CommandsTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
beforeEach(function () {
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
config(['tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
]]);
config(['tenancy.bootstrappers' => [
config([
'tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
],
'tenancy.filesystem.suffix_base' => 'tenant-',
'tenancy.filesystem.root_override.public' => '%storage_path%/app/public/',
'tenancy.filesystem.url_override.public' => 'public-%tenant_id%'
]);
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
});
afterEach(function () {
// Cleanup tenancy config cache
if (file_exists(base_path('config/tenancy.php'))) {
unlink(base_path('config/tenancy.php'));
}
});
test('migrate command doesnt change the db connection', function () {
expect(Schema::hasTable('users'))->toBeFalse();
$old_connection_name = app(\Illuminate\Database\DatabaseManager::class)->connection()->getName();
Artisan::call('tenants:migrate');
$new_connection_name = app(\Illuminate\Database\DatabaseManager::class)->connection()->getName();
expect(Schema::hasTable('users'))->toBeFalse();
expect($new_connection_name)->toEqual($old_connection_name);
pest()->assertNotEquals('tenant', $new_connection_name);
});
test('migrate command works without options', function () {
$tenant = Tenant::create();
expect(Schema::hasTable('users'))->toBeFalse();
Artisan::call('tenants:migrate');
expect(Schema::hasTable('users'))->toBeFalse();
tenancy()->initialize($tenant);
expect(Schema::hasTable('users'))->toBeTrue();
});
test('migrate command works with tenants option', function () {
$tenant = Tenant::create();
Artisan::call('tenants:migrate', [
'--tenants' => [$tenant['id']],
]);
expect(Schema::hasTable('users'))->toBeFalse();
tenancy()->initialize(Tenant::create());
expect(Schema::hasTable('users'))->toBeFalse();
tenancy()->initialize($tenant);
expect(Schema::hasTable('users'))->toBeTrue();
});
test('migrate command loads schema state', function () {
$tenant = Tenant::create();
expect(Schema::hasTable('schema_users'))->toBeFalse();
expect(Schema::hasTable('users'))->toBeFalse();
Artisan::call('tenants:migrate --schema-path="tests/Etc/tenant-schema.dump"');
expect(Schema::hasTable('schema_users'))->toBeFalse();
expect(Schema::hasTable('users'))->toBeFalse();
tenancy()->initialize($tenant);
// Check for both tables to see if missing migrations also get executed
expect(Schema::hasTable('schema_users'))->toBeTrue();
expect(Schema::hasTable('users'))->toBeTrue();
});
test('dump command works', function () {
$tenant = Tenant::create();
Artisan::call('tenants:migrate');
tenancy()->initialize($tenant);
Artisan::call('tenants:dump --path="tests/Etc/tenant-schema-test.dump"');
expect('tests/Etc/tenant-schema-test.dump')->toBeFile();
});
test('rollback command works', function () {
$tenant = Tenant::create();
Artisan::call('tenants:migrate');
expect(Schema::hasTable('users'))->toBeFalse();
tenancy()->initialize($tenant);
expect(Schema::hasTable('users'))->toBeTrue();
Artisan::call('tenants:rollback');
expect(Schema::hasTable('users'))->toBeFalse();
});
// Incomplete test
test('seed command works');
test('database connection is switched to default', function () {
databaseConnectionSwitchedToDefault();
});
test('database connection is switched to default when tenancy has been initialized', function () {
tenancy()->initialize(Tenant::create());
databaseConnectionSwitchedToDefault();
});
test('run command works', function () {
runCommandWorks();
});
test('install command works', function () {
if (! is_dir($dir = app_path('Http'))) {
mkdir($dir, 0777, true);
}
if (! is_dir($dir = base_path('routes'))) {
mkdir($dir, 0777, true);
}
public function tearDown(): void
{
parent::tearDown();
pest()->artisan('tenancy:install');
expect(base_path('routes/tenant.php'))->toBeFile();
expect(base_path('config/tenancy.php'))->toBeFile();
expect(app_path('Providers/TenancyServiceProvider.php'))->toBeFile();
expect(database_path('migrations/2019_09_15_000010_create_tenants_table.php'))->toBeFile();
expect(database_path('migrations/2019_09_15_000020_create_domains_table.php'))->toBeFile();
expect(database_path('migrations/tenant'))->toBeDirectory();
});
// Cleanup tenancy config cache
if (file_exists(base_path('config/tenancy.php'))) {
unlink(base_path('config/tenancy.php'));
}
}
test('migrate fresh command works', function () {
$tenant = Tenant::create();
/** @test */
public function migrate_command_doesnt_change_the_db_connection()
{
$this->assertFalse(Schema::hasTable('users'));
expect(Schema::hasTable('users'))->toBeFalse();
Artisan::call('tenants:migrate-fresh');
expect(Schema::hasTable('users'))->toBeFalse();
$old_connection_name = app(\Illuminate\Database\DatabaseManager::class)->connection()->getName();
Artisan::call('tenants:migrate');
$new_connection_name = app(\Illuminate\Database\DatabaseManager::class)->connection()->getName();
tenancy()->initialize($tenant);
$this->assertFalse(Schema::hasTable('users'));
$this->assertEquals($old_connection_name, $new_connection_name);
$this->assertNotEquals('tenant', $new_connection_name);
}
expect(Schema::hasTable('users'))->toBeTrue();
/** @test */
public function migrate_command_works_without_options()
{
$tenant = Tenant::create();
expect(DB::table('users')->exists())->toBeFalse();
DB::table('users')->insert(['name' => 'xxx', 'password' => bcrypt('password'), 'email' => 'foo@bar.xxx']);
expect(DB::table('users')->exists())->toBeTrue();
$this->assertFalse(Schema::hasTable('users'));
Artisan::call('tenants:migrate');
$this->assertFalse(Schema::hasTable('users'));
// test that db is wiped
Artisan::call('tenants:migrate-fresh');
expect(DB::table('users')->exists())->toBeFalse();
});
tenancy()->initialize($tenant);
test('run command with array of tenants works', function () {
$tenantId1 = Tenant::create()->getTenantKey();
$tenantId2 = Tenant::create()->getTenantKey();
Artisan::call('tenants:migrate-fresh');
$this->assertTrue(Schema::hasTable('users'));
}
pest()->artisan("tenants:run foo --tenants=$tenantId1 --tenants=$tenantId2 --argument='a=foo' --option='b=bar' --option='c=xyz'")
->expectsOutput('Tenant: ' . $tenantId1)
->expectsOutput('Tenant: ' . $tenantId2);
});
/** @test */
public function migrate_command_works_with_tenants_option()
{
$tenant = Tenant::create();
Artisan::call('tenants:migrate', [
'--tenants' => [$tenant['id']],
]);
// todo@tests
function runCommandWorks(): void
{
$id = Tenant::create()->getTenantKey();
$this->assertFalse(Schema::hasTable('users'));
tenancy()->initialize(Tenant::create());
$this->assertFalse(Schema::hasTable('users'));
Artisan::call('tenants:migrate', ['--tenants' => [$id]]);
tenancy()->initialize($tenant);
$this->assertTrue(Schema::hasTable('users'));
}
/** @test */
public function rollback_command_works()
{
$tenant = Tenant::create();
Artisan::call('tenants:migrate');
$this->assertFalse(Schema::hasTable('users'));
tenancy()->initialize($tenant);
$this->assertTrue(Schema::hasTable('users'));
Artisan::call('tenants:rollback');
$this->assertFalse(Schema::hasTable('users'));
}
/** @test */
public function seed_command_works()
{
$this->markTestIncomplete();
}
/** @test */
public function database_connection_is_switched_to_default()
{
$originalDBName = DB::connection()->getDatabaseName();
Artisan::call('tenants:migrate');
$this->assertSame($originalDBName, DB::connection()->getDatabaseName());
Artisan::call('tenants:seed', ['--class' => ExampleSeeder::class]);
$this->assertSame($originalDBName, DB::connection()->getDatabaseName());
Artisan::call('tenants:rollback');
$this->assertSame($originalDBName, DB::connection()->getDatabaseName());
$this->run_commands_works();
$this->assertSame($originalDBName, DB::connection()->getDatabaseName());
}
/** @test */
public function database_connection_is_switched_to_default_when_tenancy_has_been_initialized()
{
tenancy()->initialize(Tenant::create());
$this->database_connection_is_switched_to_default();
}
/** @test */
public function run_commands_works()
{
$id = Tenant::create()->getTenantKey();
Artisan::call('tenants:migrate', ['--tenants' => [$id]]);
$this->artisan("tenants:run foo --tenants=$id --argument='a=foo' --option='b=bar' --option='c=xyz'")
->expectsOutput("User's name is Test command")
->expectsOutput('foo')
->expectsOutput('xyz');
}
/** @test */
public function install_command_works()
{
if (! is_dir($dir = app_path('Http'))) {
mkdir($dir, 0777, true);
}
if (! is_dir($dir = base_path('routes'))) {
mkdir($dir, 0777, true);
}
$this->artisan('tenancy:install');
$this->assertFileExists(base_path('routes/tenant.php'));
$this->assertFileExists(base_path('config/tenancy.php'));
$this->assertFileExists(app_path('Providers/TenancyServiceProvider.php'));
$this->assertFileExists(database_path('migrations/2019_09_15_000010_create_tenants_table.php'));
$this->assertFileExists(database_path('migrations/2019_09_15_000020_create_domains_table.php'));
$this->assertDirectoryExists(database_path('migrations/tenant'));
}
/** @test */
public function migrate_fresh_command_works()
{
$tenant = Tenant::create();
$this->assertFalse(Schema::hasTable('users'));
Artisan::call('tenants:migrate-fresh');
$this->assertFalse(Schema::hasTable('users'));
tenancy()->initialize($tenant);
$this->assertTrue(Schema::hasTable('users'));
$this->assertFalse(DB::table('users')->exists());
DB::table('users')->insert(['name' => 'xxx', 'password' => bcrypt('password'), 'email' => 'foo@bar.xxx']);
$this->assertTrue(DB::table('users')->exists());
// test that db is wiped
Artisan::call('tenants:migrate-fresh');
$this->assertFalse(DB::table('users')->exists());
}
/** @test */
public function run_command_with_array_of_tenants_works()
{
$tenantId1 = Tenant::create()->getTenantKey();
$tenantId2 = Tenant::create()->getTenantKey();
Artisan::call('tenants:migrate-fresh');
$this->artisan("tenants:run foo --tenants=$tenantId1 --tenants=$tenantId2 --argument='a=foo' --option='b=bar' --option='c=xyz'")
->expectsOutput('Tenant: ' . $tenantId1)
->expectsOutput('Tenant: ' . $tenantId2);
}
/** @test */
public function link_command_works()
{
$tenantId1 = Tenant::create()->getTenantKey();
$tenantId2 = Tenant::create()->getTenantKey();
Artisan::call('tenants:link');
$this->assertDirectoryExists(storage_path("tenant-$tenantId1/app/public"));
$this->assertEquals(storage_path("tenant-$tenantId1/app/public/"), readlink(public_path("public-$tenantId1")));
$this->assertDirectoryExists(storage_path("tenant-$tenantId2/app/public"));
$this->assertEquals(storage_path("tenant-$tenantId2/app/public/"), readlink(public_path("public-$tenantId2")));
Artisan::call('tenants:link', [
'--remove' => true,
]);
$this->assertDirectoryDoesNotExist(public_path("public-$tenantId1"));
$this->assertDirectoryDoesNotExist(public_path("public-$tenantId2"));
}
/** @test */
public function link_command_with_tenant_specified_works()
{
$tenant_key = Tenant::create()->getTenantKey();
Artisan::call('tenants:link', [
'--tenants' => [$tenant_key],
]);
$this->assertDirectoryExists(storage_path("tenant-$tenant_key/app/public"));
$this->assertEquals(storage_path("tenant-$tenant_key/app/public/"), readlink(public_path("public-$tenant_key")));
Artisan::call('tenants:link', [
'--remove' => true,
'--tenants' => [$tenant_key],
]);
$this->assertDirectoryDoesNotExist(public_path("public-$tenant_key"));
}
pest()->artisan("tenants:run foo --tenants=$id --argument='a=foo' --option='b=bar' --option='c=xyz'")
->expectsOutput("User's name is Test command")
->expectsOutput('foo')
->expectsOutput('xyz');
}
// todo@tests
function databaseConnectionSwitchedToDefault()
{
$originalDBName = DB::connection()->getDatabaseName();
Artisan::call('tenants:migrate');
expect(DB::connection()->getDatabaseName())->toBe($originalDBName);
Artisan::call('tenants:seed', ['--class' => ExampleSeeder::class]);
expect(DB::connection()->getDatabaseName())->toBe($originalDBName);
Artisan::call('tenants:rollback');
expect(DB::connection()->getDatabaseName())->toBe($originalDBName);
runCommandWorks();
expect(DB::connection()->getDatabaseName())->toBe($originalDBName);
}

145
tests/DatabasePreparationTest.php
View file

@ -2,11 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Database\Seeder;
use Illuminate\Foundation\Auth\User as Authenticable;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Schema;
use Stancl\JobPipeline\JobPipeline;
@ -16,111 +11,85 @@ use Stancl\Tenancy\Jobs\MigrateDatabase;
use Stancl\Tenancy\Jobs\SeedDatabase;
use Stancl\Tenancy\TenantDatabaseManagers\MySQLDatabaseManager;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Illuminate\Foundation\Auth\User as Authenticable;
use Stancl\Tenancy\Tests\Etc\TestSeeder;
class DatabasePreparationTest extends TestCase
{
/** @test */
public function database_can_be_created_after_tenant_creation()
{
config(['tenancy.database.template_tenant_connection' => 'mysql']);
test('database can be created after tenant creation', function () {
config(['tenancy.database.template_tenant_connection' => 'mysql']);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$tenant = Tenant::create();
$tenant = Tenant::create();
$manager = app(MySQLDatabaseManager::class);
$manager->setConnection('mysql');
$manager = app(MySQLDatabaseManager::class);
$manager->setConnection('mysql');
$this->assertTrue($manager->databaseExists($tenant->database()->getName()));
}
expect($manager->databaseExists($tenant->database()->getName()))->toBeTrue();
});
/** @test */
public function database_can_be_migrated_after_tenant_creation()
{
Event::listen(TenantCreated::class, JobPipeline::make([
CreateDatabase::class,
MigrateDatabase::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
test('database can be migrated after tenant creation', function () {
Event::listen(TenantCreated::class, JobPipeline::make([
CreateDatabase::class,
MigrateDatabase::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$tenant = Tenant::create();
$tenant = Tenant::create();
$tenant->run(function () {
$this->assertTrue(Schema::hasTable('users'));
});
}
$tenant->run(function () {
expect(Schema::hasTable('users'))->toBeTrue();
});
});
/** @test */
public function database_can_be_seeded_after_tenant_creation()
{
config(['tenancy.seeder_parameters' => [
'--class' => TestSeeder::class,
]]);
test('database can be seeded after tenant creation', function () {
config(['tenancy.seeder_parameters' => [
'--class' => TestSeeder::class,
]]);
Event::listen(TenantCreated::class, JobPipeline::make([
CreateDatabase::class,
MigrateDatabase::class,
SeedDatabase::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenantCreated::class, JobPipeline::make([
CreateDatabase::class,
MigrateDatabase::class,
SeedDatabase::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$tenant = Tenant::create();
$tenant = Tenant::create();
$tenant->run(function () {
$this->assertSame('Seeded User', User::first()->name);
});
}
$tenant->run(function () {
expect(User::first()->name)->toBe('Seeded User');
});
});
/** @test */
public function custom_job_can_be_added_to_the_pipeline()
{
config(['tenancy.seeder_parameters' => [
'--class' => TestSeeder::class,
]]);
test('custom job can be added to the pipeline', function () {
config(['tenancy.seeder_parameters' => [
'--class' => TestSeeder::class,
]]);
Event::listen(TenantCreated::class, JobPipeline::make([
CreateDatabase::class,
MigrateDatabase::class,
SeedDatabase::class,
CreateSuperuser::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenantCreated::class, JobPipeline::make([
CreateDatabase::class,
MigrateDatabase::class,
SeedDatabase::class,
CreateSuperuser::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$tenant = Tenant::create();
$tenant = Tenant::create();
$tenant->run(function () {
$this->assertSame('Foo', User::all()[1]->name);
});
}
}
$tenant->run(function () {
expect(User::all()[1]->name)->toBe('Foo');
});
});
class User extends Authenticable
{
protected $guarded = [];
}
class TestSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('users')->insert([
'name' => 'Seeded User',
'email' => 'seeded@user',
'password' => bcrypt('password'),
]);
}
}
class CreateSuperuser
{
protected $tenant;

159
tests/DatabaseUsersTest.php
View file

@ -2,14 +2,13 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Str;
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
use Stancl\Tenancy\Contracts\ManagesDatabaseUsers;
use Stancl\Tenancy\Events\DatabaseCreated;
use Stancl\Tenancy\Events\TenancyInitialized;
use Stancl\Tenancy\Events\TenantCreated;
use Stancl\Tenancy\Exceptions\TenantDatabaseUserAlreadyExistsException;
@ -19,107 +18,97 @@ use Stancl\Tenancy\TenantDatabaseManagers\MySQLDatabaseManager;
use Stancl\Tenancy\TenantDatabaseManagers\PermissionControlledMySQLDatabaseManager;
use Stancl\Tenancy\Tests\Etc\Tenant;
class DatabaseUsersTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
beforeEach(function () {
config([
'tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class,
'tenancy.database.suffix' => '',
'tenancy.database.template_tenant_connection' => 'mysql',
]);
config([
'tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class,
'tenancy.database.suffix' => '',
'tenancy.database.template_tenant_connection' => 'mysql',
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
});
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
}
test('users are created when permission controlled mysql manager is used', function () {
$tenant = new Tenant([
'id' => 'foo' . Str::random(10),
]);
$tenant->database()->makeCredentials();
/** @test */
public function users_are_created_when_permission_controlled_mysql_manager_is_used()
{
$tenant = new Tenant([
'id' => 'foo' . Str::random(10),
]);
$tenant->database()->makeCredentials();
/** @var ManagesDatabaseUsers $manager */
$manager = $tenant->database()->manager();
expect($manager->userExists($tenant->database()->getUsername()))->toBeFalse();
/** @var ManagesDatabaseUsers $manager */
$manager = $tenant->database()->manager();
$this->assertFalse($manager->userExists($tenant->database()->getUsername()));
$tenant->save();
$tenant->save();
expect($manager->userExists($tenant->database()->getUsername()))->toBeTrue();
});
$this->assertTrue($manager->userExists($tenant->database()->getUsername()));
}
test('a tenants database cannot be created when the user already exists', function () {
$username = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_username' => $username,
]);
/** @test */
public function a_tenants_database_cannot_be_created_when_the_user_already_exists()
{
$username = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_username' => $username,
]);
/** @var ManagesDatabaseUsers $manager */
$manager = $tenant->database()->manager();
expect($manager->userExists($tenant->database()->getUsername()))->toBeTrue();
expect($manager->databaseExists($tenant->database()->getName()))->toBeTrue();
/** @var ManagesDatabaseUsers $manager */
$manager = $tenant->database()->manager();
$this->assertTrue($manager->userExists($tenant->database()->getUsername()));
$this->assertTrue($manager->databaseExists($tenant->database()->getName()));
pest()->expectException(TenantDatabaseUserAlreadyExistsException::class);
Event::fake([DatabaseCreated::class]);
$this->expectException(TenantDatabaseUserAlreadyExistsException::class);
$tenant2 = Tenant::create([
'tenancy_db_username' => $username,
]);
$tenant2 = Tenant::create([
'tenancy_db_username' => $username,
]);
/** @var ManagesDatabaseUsers $manager */
$manager = $tenant2->database()->manager();
// database was not created because of DB transaction
$this->assertFalse($manager->databaseExists($tenant2->database()->getName()));
}
/** @var ManagesDatabaseUsers $manager */
$manager2 = $tenant2->database()->manager();
/** @test */
public function correct_grants_are_given_to_users()
{
PermissionControlledMySQLDatabaseManager::$grants = [
'ALTER', 'ALTER ROUTINE', 'CREATE',
];
// database was not created because of DB transaction
expect($manager2->databaseExists($tenant2->database()->getName()))->toBeFalse();
Event::assertNotDispatched(DatabaseCreated::class);
});
$tenant = Tenant::create([
'tenancy_db_username' => $user = 'user' . Str::random(8),
]);
test('correct grants are given to users', function () {
PermissionControlledMySQLDatabaseManager::$grants = [
'ALTER', 'ALTER ROUTINE', 'CREATE',
];
$query = DB::connection('mysql')->select("SHOW GRANTS FOR `{$tenant->database()->getUsername()}`@`%`")[1];
$this->assertStringStartsWith('GRANT CREATE, ALTER, ALTER ROUTINE ON', $query->{"Grants for {$user}@%"}); // @mysql because that's the hostname within the docker network
}
$tenant = Tenant::create([
'tenancy_db_username' => $user = 'user' . Str::random(8),
]);
/** @test */
public function having_existing_databases_without_users_and_switching_to_permission_controlled_mysql_manager_doesnt_break_existing_dbs()
{
config([
'tenancy.database.managers.mysql' => MySQLDatabaseManager::class,
'tenancy.database.suffix' => '',
'tenancy.database.template_tenant_connection' => 'mysql',
'tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
$query = DB::connection('mysql')->select("SHOW GRANTS FOR `{$tenant->database()->getUsername()}`@`%`")[1];
expect($query->{"Grants for {$user}@%"})->toStartWith('GRANT CREATE, ALTER, ALTER ROUTINE ON'); // @mysql because that's the hostname within the docker network
});
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
test('having existing databases without users and switching to permission controlled mysql manager doesnt break existing dbs', function () {
config([
'tenancy.database.managers.mysql' => MySQLDatabaseManager::class,
'tenancy.database.suffix' => '',
'tenancy.database.template_tenant_connection' => 'mysql',
'tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
$tenant = Tenant::create([
'id' => 'foo' . Str::random(10),
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
$this->assertTrue($tenant->database()->manager() instanceof MySQLDatabaseManager);
$tenant = Tenant::create([
'id' => 'foo' . Str::random(10),
]);
tenancy()->initialize($tenant); // check if everything works
tenancy()->end();
expect($tenant->database()->manager() instanceof MySQLDatabaseManager)->toBeTrue();
config(['tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class]);
tenancy()->initialize($tenant); // check if everything works
tenancy()->end();
tenancy()->initialize($tenant); // check if everything works
config(['tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class]);
$this->assertTrue($tenant->database()->manager() instanceof PermissionControlledMySQLDatabaseManager);
$this->assertSame('root', config('database.connections.tenant.username'));
}
}
tenancy()->initialize($tenant); // check if everything works
expect($tenant->database()->manager() instanceof PermissionControlledMySQLDatabaseManager)->toBeTrue();
expect(config('database.connections.tenant.username'))->toBe('root');
});

32
tests/DeleteDomainsJobTest.php Normal file
View file

@ -0,0 +1,32 @@
<?php
declare(strict_types=1);
use Stancl\Tenancy\Database\Concerns\HasDomains;
use Stancl\Tenancy\Jobs\DeleteDomains;
beforeEach(function () {
config(['tenancy.tenant_model' => DatabaseAndDomainTenant::class]);
});
test('job delete domains successfully', function (){
$tenant = DatabaseAndDomainTenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$tenant->domains()->create([
'domain' => 'bar.localhost',
]);
expect($tenant->domains()->count())->toBe(2);
(new DeleteDomains($tenant))->handle();
expect($tenant->refresh()->domains()->count())->toBe(0);
});
class DatabaseAndDomainTenant extends \Stancl\Tenancy\Tests\Etc\Tenant
{
use HasDomains;
}

158
tests/DomainTest.php
View file

@ -2,121 +2,113 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Database\Concerns\HasDomains;
use Stancl\Tenancy\Database\Models;
use Stancl\Tenancy\Database\Models\Domain;
use Stancl\Tenancy\Exceptions\DomainOccupiedByOtherTenantException;
use Stancl\Tenancy\Exceptions\TenantCouldNotBeIdentifiedOnDomainException;
use Stancl\Tenancy\Features\UniversalRoutes;
use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
use Stancl\Tenancy\Resolvers\DomainTenantResolver;
class DomainTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
Route::group([
'middleware' => InitializeTenancyByDomain::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
beforeEach(function () {
Route::group([
'middleware' => InitializeTenancyByDomain::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
});
config(['tenancy.tenant_model' => DomainTenant::class]);
}
config(['tenancy.tenant_model' => DomainTenant::class]);
});
/** @test */
public function tenant_can_be_identified_using_hostname()
{
$tenant = DomainTenant::create();
test('tenant can be identified using hostname', function () {
$tenant = DomainTenant::create();
$id = $tenant->id;
$id = $tenant->id;
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$resolvedTenant = app(DomainTenantResolver::class)->resolve('foo.localhost');
$resolvedTenant = app(DomainTenantResolver::class)->resolve('foo.localhost');
$this->assertSame($id, $resolvedTenant->id);
$this->assertSame(['foo.localhost'], $resolvedTenant->domains->pluck('domain')->toArray());
}
expect($resolvedTenant->id)->toBe($id);
expect($resolvedTenant->domains->pluck('domain')->toArray())->toBe(['foo.localhost']);
});
/** @test */
public function a_domain_can_belong_to_only_one_tenant()
{
$tenant = DomainTenant::create();
test('a domain can belong to only one tenant', function () {
$tenant = DomainTenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$tenant2 = DomainTenant::create();
$tenant2 = DomainTenant::create();
$this->expectException(DomainOccupiedByOtherTenantException::class);
$tenant2->domains()->create([
'domain' => 'foo.localhost',
]);
}
pest()->expectException(DomainOccupiedByOtherTenantException::class);
$tenant2->domains()->create([
'domain' => 'foo.localhost',
]);
});
/** @test */
public function an_exception_is_thrown_if_tenant_cannot_be_identified()
{
$this->expectException(TenantCouldNotBeIdentifiedOnDomainException::class);
test('an exception is thrown if tenant cannot be identified', function () {
pest()->expectException(TenantCouldNotBeIdentifiedOnDomainException::class);
app(DomainTenantResolver::class)->resolve('foo.localhost');
}
app(DomainTenantResolver::class)->resolve('foo.localhost');
});
/** @test */
public function tenant_can_be_identified_by_domain()
{
$tenant = DomainTenant::create([
'id' => 'acme',
]);
test('tenant can be identified by domain', function () {
$tenant = DomainTenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$this->assertFalse(tenancy()->initialized);
expect(tenancy()->initialized)->toBeFalse();
$this
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
pest()
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
$this->assertTrue(tenancy()->initialized);
$this->assertSame('acme', tenant('id'));
}
expect(tenancy()->initialized)->toBeTrue();
expect(tenant('id'))->toBe('acme');
});
/** @test */
public function onfail_logic_can_be_customized()
{
InitializeTenancyByDomain::$onFail = function () {
return 'foo';
};
test('onfail logic can be customized', function () {
InitializeTenancyByDomain::$onFail = function () {
return 'foo';
};
$this
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('foo');
}
pest()
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('foo');
});
/** @test */
public function domains_are_always_lowercase()
{
$tenant = DomainTenant::create();
test('throw correct exception when onFail is null and universal routes are enabled', function () {
// un-define onFail logic
InitializeTenancyByDomain::$onFail = null;
$tenant->domains()->create([
'domain' => 'CAPITALS',
]);
// Enable UniversalRoute feature
Route::middlewareGroup('universal', []);
config(['tenancy.features' => [UniversalRoutes::class]]);
$this->assertSame('capitals', Domain::first()->domain);
}
}
$this->withoutExceptionHandling()->get('http://foo.localhost/foo/abc/xyz');
})->throws(TenantCouldNotBeIdentifiedOnDomainException::class);;
test('domains are always lowercase', function () {
$tenant = DomainTenant::create();
$tenant->domains()->create([
'domain' => 'CAPITALS',
]);
expect(Domain::first()->domain)->toBe('capitals');
});
class DomainTenant extends Models\Tenant
{

7
tests/Etc/ConsoleKernel.php
View file

@ -4,15 +4,10 @@ declare(strict_types=1);
namespace Stancl\Tenancy\Tests\Etc;
use Orchestra\Testbench\Console\Kernel;
use Orchestra\Testbench\Foundation\Console\Kernel;
class ConsoleKernel extends Kernel
{
/**
* The Artisan commands provided by your application.
*
* @var array
*/
protected $commands = [
ExampleCommand::class,
AddUserCommand::class,

2
tests/Etc/ExampleSeeder.php
View file

@ -19,7 +19,7 @@ class ExampleSeeder extends Seeder
{
DB::table('users')->insert([
'name' => Str::random(10),
'email' => Str::random(10).'@gmail.com',
'email' => Str::random(10) . '@gmail.com',
'password' => bcrypt('password'),
]);
}

23
tests/Etc/TestSeeder.php Normal file
View file

@ -0,0 +1,23 @@
<?php
namespace Stancl\Tenancy\Tests\Etc;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
class TestSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('users')->insert([
'name' => 'Seeded User',
'email' => 'seeded@user',
'password' => bcrypt('password'),
]);
}
}

66
tests/Etc/tenant-schema.dump Normal file
View file

@ -0,0 +1,66 @@
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
DROP TABLE IF EXISTS `failed_jobs`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `failed_jobs` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`uuid` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
`connection` text COLLATE utf8mb4_unicode_ci NOT NULL,
`queue` text COLLATE utf8mb4_unicode_ci NOT NULL,
`payload` longtext COLLATE utf8mb4_unicode_ci NOT NULL,
`exception` longtext COLLATE utf8mb4_unicode_ci NOT NULL,
`failed_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (`id`),
UNIQUE KEY `failed_jobs_uuid_unique` (`uuid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `migrations`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `migrations` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`migration` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
`batch` int(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `password_resets`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `password_resets` (
`email` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
`token` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
`created_at` timestamp NULL DEFAULT NULL,
KEY `password_resets_email_index` (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
DROP TABLE IF EXISTS `users`;
/*!40101 SET @saved_cs_client = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `schema_users` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
`email` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
`email_verified_at` timestamp NULL DEFAULT NULL,
`password` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
`remember_token` varchar(100) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
`created_at` timestamp NULL DEFAULT NULL,
`updated_at` timestamp NULL DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `users_email_unique` (`email`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
/*!40101 SET character_set_client = @saved_cs_client */;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
INSERT INTO `migrations` VALUES (2,'2014_10_12_100000_testbench_create_password_resets_table',1);
INSERT INTO `migrations` VALUES (3,'2019_08_19_000000_testbench_create_failed_jobs_table',1);

1
tests/Etc/tmp/queuetest.json
View file

@ -1 +0,0 @@
{"tenant_id":"The current tenant id is: acme"}

268
tests/EventListenerTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Events\CallQueuedListener;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Queue;
@ -20,186 +18,166 @@ use Stancl\Tenancy\Jobs\CreateDatabase;
use Stancl\Tenancy\Jobs\MigrateDatabase;
use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Listeners\QueueableListener;
use Stancl\Tenancy\Tenancy;
use Stancl\Tenancy\Tests\Etc\Tenant;
class EventListenerTest extends TestCase
{
/** @test */
public function listeners_can_be_synchronous()
{
Queue::fake();
Event::listen(TenantCreated::class, FooListener::class);
test('listeners can be synchronous', function () {
Queue::fake();
Event::listen(TenantCreated::class, FooListener::class);
Tenant::create();
Tenant::create();
Queue::assertNothingPushed();
Queue::assertNothingPushed();
$this->assertSame('bar', app('foo'));
}
expect(app('foo'))->toBe('bar');
});
/** @test */
public function listeners_can_be_queued_by_setting_a_static_property()
{
Queue::fake();
test('listeners can be queued by setting a static property', function () {
Queue::fake();
Event::listen(TenantCreated::class, FooListener::class);
FooListener::$shouldQueue = true;
Event::listen(TenantCreated::class, FooListener::class);
FooListener::$shouldQueue = true;
Tenant::create();
Tenant::create();
Queue::assertPushed(CallQueuedListener::class, function (CallQueuedListener $job) {
return $job->class === FooListener::class;
});
Queue::assertPushed(CallQueuedListener::class, function (CallQueuedListener $job) {
return $job->class === FooListener::class;
});
$this->assertFalse(app()->bound('foo'));
}
expect(app()->bound('foo'))->toBeFalse();
});
/** @test */
public function ing_events_can_be_used_to_cancel_tenant_model_actions()
{
Event::listen(CreatingTenant::class, function () {
return false;
});
test('ing events can be used to cancel tenant model actions', function () {
Event::listen(CreatingTenant::class, function () {
return false;
});
$this->assertSame(false, Tenant::create()->exists);
$this->assertSame(0, Tenant::count());
}
expect(Tenant::create()->exists)->toBe(false);
expect(Tenant::count())->toBe(0);
});
/** @test */
public function ing_events_can_be_used_to_cancel_domain_model_actions()
{
$tenant = Tenant::create();
test('ing events can be used to cancel domain model actions', function () {
$tenant = Tenant::create();
Event::listen(UpdatingDomain::class, function () {
return false;
});
Event::listen(UpdatingDomain::class, function () {
return false;
});
$domain = $tenant->domains()->create([
'domain' => 'acme',
]);
$domain = $tenant->domains()->create([
'domain' => 'acme',
]);
$domain->update([
'domain' => 'foo',
]);
$domain->update([
'domain' => 'foo',
]);
$this->assertSame('acme', $domain->refresh()->domain);
}
expect($domain->refresh()->domain)->toBe('acme');
});
/** @test */
public function ing_events_can_be_used_to_cancel_db_creation()
{
Event::listen(CreatingDatabase::class, function (CreatingDatabase $event) {
$event->tenant->setInternal('create_database', false);
});
test('ing events can be used to cancel db creation', function () {
Event::listen(CreatingDatabase::class, function (CreatingDatabase $event) {
$event->tenant->setInternal('create_database', false);
});
$tenant = Tenant::create();
dispatch_now(new CreateDatabase($tenant));
$tenant = Tenant::create();
dispatch_now(new CreateDatabase($tenant));
$this->assertFalse($tenant->database()->manager()->databaseExists(
$tenant->database()->getName()
));
}
pest()->assertFalse($tenant->database()->manager()->databaseExists(
$tenant->database()->getName()
));
});
/** @test */
public function ing_events_can_be_used_to_cancel_tenancy_bootstrapping()
{
config(['tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
RedisTenancyBootstrapper::class,
]]);
test('ing events can be used to cancel tenancy bootstrapping', function () {
config(['tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
RedisTenancyBootstrapper::class,
]]);
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(BootstrappingTenancy::class, function (BootstrappingTenancy $event) {
$event->tenancy->getBootstrappersUsing = function () {
return [DatabaseTenancyBootstrapper::class];
};
});
Event::listen(BootstrappingTenancy::class, function (BootstrappingTenancy $event) {
$event->tenancy->getBootstrappersUsing = function () {
return [DatabaseTenancyBootstrapper::class];
};
});
tenancy()->initialize(Tenant::create());
tenancy()->initialize(Tenant::create());
$this->assertSame([DatabaseTenancyBootstrapper::class], array_map('get_class', tenancy()->getBootstrappers()));
}
expect(array_map('get_class', tenancy()->getBootstrappers()))->toBe([DatabaseTenancyBootstrapper::class]);
});
/** @test */
public function individual_job_pipelines_can_terminate_while_leaving_others_running()
{
$executed = [];
test('individual job pipelines can terminate while leaving others running', function () {
$executed = [];
Event::listen(
TenantCreated::class,
JobPipeline::make([
function () use (&$executed) {
$executed[] = 'P1J1';
},
Event::listen(
TenantCreated::class,
JobPipeline::make([
function () use (&$executed) {
$executed[] = 'P1J1';
},
function () use (&$executed) {
$executed[] = 'P1J2';
},
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
function () use (&$executed) {
$executed[] = 'P1J2';
},
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(
TenantCreated::class,
JobPipeline::make([
function () use (&$executed) {
$executed[] = 'P2J1';
Event::listen(
TenantCreated::class,
JobPipeline::make([
function () use (&$executed) {
$executed[] = 'P2J1';
return false;
},
return false;
},
function () use (&$executed) {
$executed[] = 'P2J2';
},
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
function () use (&$executed) {
$executed[] = 'P2J2';
},
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Tenant::create();
Tenant::create();
$this->assertSame([
'P1J1',
'P1J2',
'P2J1', // termminated after this
// P2J2 was not reached
], $executed);
}
pest()->assertSame([
'P1J1',
'P1J2',
'P2J1', // termminated after this
// P2J2 was not reached
], $executed);
});
/** @test */
public function database_is_not_migrated_if_creation_is_disabled()
{
Event::listen(
TenantCreated::class,
JobPipeline::make([
CreateDatabase::class,
function () {
$this->fail("The job pipeline didn't exit.");
},
MigrateDatabase::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
test('database is not migrated if creation is disabled', function () {
Event::listen(
TenantCreated::class,
JobPipeline::make([
CreateDatabase::class,
function () {
pest()->fail("The job pipeline didn't exit.");
},
MigrateDatabase::class,
])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Tenant::create([
'tenancy_create_database' => false,
'tenancy_db_name' => 'already_created',
]);
Tenant::create([
'tenancy_create_database' => false,
'tenancy_db_name' => 'already_created',
]);
$this->assertFalse($this->hasFailed());
}
}
expect(pest()->hasFailed())->toBeFalse();
});
class FooListener extends QueueableListener
{

54
tests/Features/RedirectTest.php
View file

@ -2,45 +2,35 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests\Features;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Features\CrossDomainRedirect;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Stancl\Tenancy\Tests\TestCase;
class RedirectTest extends TestCase
{
/** @test */
public function tenant_redirect_macro_replaces_only_the_hostname()
{
config([
'tenancy.features' => [CrossDomainRedirect::class],
]);
test('tenant redirect macro replaces only the hostname', function () {
config([
'tenancy.features' => [CrossDomainRedirect::class],
]);
Route::get('/foobar', function () {
return 'Foo';
})->name('home');
Route::get('/foobar', function () {
return 'Foo';
})->name('home');
Route::get('/redirect', function () {
return redirect()->route('home')->domain('abcd');
});
Route::get('/redirect', function () {
return redirect()->route('home')->domain('abcd');
});
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$this->get('/redirect')
->assertRedirect('http://abcd/foobar');
}
pest()->get('/redirect')
->assertRedirect('http://abcd/foobar');
});
/** @test */
public function tenant_route_helper_generates_correct_url()
{
Route::get('/abcdef/{a?}/{b?}', function () {
return 'Foo';
})->name('foo');
test('tenant route helper generates correct url', function () {
Route::get('/abcdef/{a?}/{b?}', function () {
return 'Foo';
})->name('foo');
$this->assertSame('http://foo.localhost/abcdef/as/df', tenant_route('foo.localhost', 'foo', ['a' => 'as', 'b' => 'df']));
$this->assertSame('http://foo.localhost/abcdef', tenant_route('foo.localhost', 'foo', []));
}
}
expect(tenant_route('foo.localhost', 'foo', ['a' => 'as', 'b' => 'df']))->toBe('http://foo.localhost/abcdef/as/df');
expect(tenant_route('foo.localhost', 'foo', []))->toBe('http://foo.localhost/abcdef');
});

131
tests/Features/TenantConfigTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests\Features;
use Illuminate\Support\Facades\Event;
use Stancl\Tenancy\Events\TenancyEnded;
use Stancl\Tenancy\Events\TenancyInitialized;
@ -11,84 +9,73 @@ use Stancl\Tenancy\Features\TenantConfig;
use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Stancl\Tenancy\Tests\TestCase;
class TenantConfigTest extends TestCase
{
public function tearDown(): void
{
TenantConfig::$storageToConfigMap = [];
afterEach(function () {
TenantConfig::$storageToConfigMap = [];
});
parent::tearDown();
}
test('config is merged and removed', function () {
expect(config('services.paypal'))->toBe(null);
config([
'tenancy.features' => [TenantConfig::class],
'tenancy.bootstrappers' => [],
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
/** @test */
public function config_is_merged_and_removed()
{
$this->assertSame(null, config('services.paypal'));
config([
'tenancy.features' => [TenantConfig::class],
'tenancy.bootstrappers' => [],
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
TenantConfig::$storageToConfigMap = [
'paypal_api_public' => 'services.paypal.public',
'paypal_api_private' => 'services.paypal.private',
];
TenantConfig::$storageToConfigMap = [
'paypal_api_public' => 'services.paypal.public',
'paypal_api_private' => 'services.paypal.private',
];
$tenant = Tenant::create([
'paypal_api_public' => 'foo',
'paypal_api_private' => 'bar',
]);
$tenant = Tenant::create([
'paypal_api_public' => 'foo',
'paypal_api_private' => 'bar',
]);
tenancy()->initialize($tenant);
expect(config('services.paypal'))->toBe(['public' => 'foo', 'private' => 'bar']);
tenancy()->initialize($tenant);
$this->assertSame(['public' => 'foo', 'private' => 'bar'], config('services.paypal'));
tenancy()->end();
pest()->assertSame([
'public' => null,
'private' => null,
], config('services.paypal'));
});
tenancy()->end();
$this->assertSame([
'public' => null,
'private' => null,
], config('services.paypal'));
}
test('the value can be set to multiple config keys', function () {
expect(config('services.paypal'))->toBe(null);
config([
'tenancy.features' => [TenantConfig::class],
'tenancy.bootstrappers' => [],
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
/** @test */
public function the_value_can_be_set_to_multiple_config_keys()
{
$this->assertSame(null, config('services.paypal'));
config([
'tenancy.features' => [TenantConfig::class],
'tenancy.bootstrappers' => [],
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
TenantConfig::$storageToConfigMap = [
'paypal_api_public' => [
'services.paypal.public1',
'services.paypal.public2',
],
'paypal_api_private' => 'services.paypal.private',
];
TenantConfig::$storageToConfigMap = [
'paypal_api_public' => [
'services.paypal.public1',
'services.paypal.public2',
],
'paypal_api_private' => 'services.paypal.private',
];
$tenant = Tenant::create([
'paypal_api_public' => 'foo',
'paypal_api_private' => 'bar',
]);
$tenant = Tenant::create([
'paypal_api_public' => 'foo',
'paypal_api_private' => 'bar',
]);
tenancy()->initialize($tenant);
pest()->assertSame([
'public1' => 'foo',
'public2' => 'foo',
'private' => 'bar',
], config('services.paypal'));
tenancy()->initialize($tenant);
$this->assertSame([
'public1' => 'foo',
'public2' => 'foo',
'private' => 'bar',
], config('services.paypal'));
tenancy()->end();
$this->assertSame([
'public1' => null,
'public2' => null,
'private' => null,
], config('services.paypal'));
}
}
tenancy()->end();
pest()->assertSame([
'public1' => null,
'public2' => null,
'private' => null,
], config('services.paypal'));
});

71
tests/GlobalCacheTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Event;
use Stancl\Tenancy\Bootstrappers\CacheTenancyBootstrapper;
use Stancl\Tenancy\Events\TenancyEnded;
@ -13,49 +11,42 @@ use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\Tests\Etc\Tenant;
class GlobalCacheTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
beforeEach(function () {
config(['tenancy.bootstrappers' => [
CacheTenancyBootstrapper::class,
]]);
config(['tenancy.bootstrappers' => [
CacheTenancyBootstrapper::class,
]]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
});
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
}
test('global cache manager stores data in global cache', function () {
expect(cache('foo'))->toBe(null);
GlobalCache::put(['foo' => 'bar'], 1);
expect(GlobalCache::get('foo'))->toBe('bar');
/** @test */
public function global_cache_manager_stores_data_in_global_cache()
{
$this->assertSame(null, cache('foo'));
GlobalCache::put(['foo' => 'bar'], 1);
$this->assertSame('bar', GlobalCache::get('foo'));
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
expect(GlobalCache::get('foo'))->toBe('bar');
$tenant1 = Tenant::create();
tenancy()->initialize($tenant1);
$this->assertSame('bar', GlobalCache::get('foo'));
GlobalCache::put(['abc' => 'xyz'], 1);
cache(['def' => 'ghi'], 10);
expect(cache('def'))->toBe('ghi');
GlobalCache::put(['abc' => 'xyz'], 1);
cache(['def' => 'ghi'], 10);
$this->assertSame('ghi', cache('def'));
tenancy()->end();
expect(GlobalCache::get('abc'))->toBe('xyz');
expect(GlobalCache::get('foo'))->toBe('bar');
expect(cache('def'))->toBe(null);
tenancy()->end();
$this->assertSame('xyz', GlobalCache::get('abc'));
$this->assertSame('bar', GlobalCache::get('foo'));
$this->assertSame(null, cache('def'));
$tenant2 = Tenant::create();
tenancy()->initialize($tenant2);
expect(GlobalCache::get('abc'))->toBe('xyz');
expect(GlobalCache::get('foo'))->toBe('bar');
expect(cache('def'))->toBe(null);
cache(['def' => 'xxx'], 1);
expect(cache('def'))->toBe('xxx');
$tenant2 = Tenant::create();
tenancy()->initialize($tenant2);
$this->assertSame('xyz', GlobalCache::get('abc'));
$this->assertSame('bar', GlobalCache::get('foo'));
$this->assertSame(null, cache('def'));
cache(['def' => 'xxx'], 1);
$this->assertSame('xxx', cache('def'));
tenancy()->initialize($tenant1);
expect(cache('def'))->toBe('ghi');
});
tenancy()->initialize($tenant1);
$this->assertSame('ghi', cache('def'));
}
}

43
tests/MaintenanceModeTest.php
View file

@ -2,41 +2,34 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Foundation\Http\Exceptions\MaintenanceModeException;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Database\Concerns\MaintenanceMode;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Middleware\CheckTenantForMaintenanceMode;
use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
use Stancl\Tenancy\Tests\Etc\Tenant;
class MaintenanceModeTest extends TestCase
{
/** @test */
public function tenant_can_be_in_maintenance_mode()
{
Route::get('/foo', function () {
return 'bar';
})->middleware([InitializeTenancyByDomain::class, CheckTenantForMaintenanceMode::class]);
test('tenant can be in maintenance mode', function () {
Route::get('/foo', function () {
return 'bar';
})->middleware([InitializeTenancyByDomain::class, CheckTenantForMaintenanceMode::class]);
$tenant = MaintenanceTenant::create();
$tenant->domains()->create([
'domain' => 'acme.localhost',
]);
$tenant = MaintenanceTenant::create();
$tenant->domains()->create([
'domain' => 'acme.localhost',
]);
$this->get('http://acme.localhost/foo')
->assertSuccessful();
pest()->get('http://acme.localhost/foo')
->assertSuccessful();
tenancy()->end(); // flush stored tenant instance
tenancy()->end(); // flush stored tenant instance
$tenant->putDownForMaintenance();
$tenant->putDownForMaintenance();
$this->expectException(MaintenanceModeException::class);
$this->withoutExceptionHandling()
->get('http://acme.localhost/foo');
}
}
pest()->expectException(HttpException::class);
pest()->withoutExceptionHandling()
->get('http://acme.localhost/foo');
});
class MaintenanceTenant extends Tenant
{

195
tests/PathIdentificationTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Exceptions\RouteIsMissingTenantParameterException;
use Stancl\Tenancy\Exceptions\TenantCouldNotBeIdentifiedByPathException;
@ -11,138 +9,117 @@ use Stancl\Tenancy\Middleware\InitializeTenancyByPath;
use Stancl\Tenancy\Resolvers\PathTenantResolver;
use Stancl\Tenancy\Tests\Etc\Tenant;
class PathIdentificationTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
beforeEach(function () {
PathTenantResolver::$tenantParameterName = 'tenant';
PathTenantResolver::$tenantParameterName = 'tenant';
Route::group([
'prefix' => '/{tenant}',
'middleware' => InitializeTenancyByPath::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
Route::group([
'prefix' => '/{tenant}',
'middleware' => InitializeTenancyByPath::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
}
});
});
public function tearDown(): void
{
parent::tearDown();
afterEach(function () {
// Global state cleanup
PathTenantResolver::$tenantParameterName = 'tenant';
});
// Global state cleanup
PathTenantResolver::$tenantParameterName = 'tenant';
}
test('tenant can be identified by path', function () {
Tenant::create([
'id' => 'acme',
]);
/** @test */
public function tenant_can_be_identified_by_path()
{
Tenant::create([
'id' => 'acme',
]);
expect(tenancy()->initialized)->toBeFalse();
$this->assertFalse(tenancy()->initialized);
pest()->get('/acme/foo/abc/xyz');
$this->get('/acme/foo/abc/xyz');
expect(tenancy()->initialized)->toBeTrue();
expect(tenant('id'))->toBe('acme');
});
$this->assertTrue(tenancy()->initialized);
$this->assertSame('acme', tenant('id'));
}
test('route actions dont get the tenant id', function () {
Tenant::create([
'id' => 'acme',
]);
/** @test */
public function route_actions_dont_get_the_tenant_id()
{
Tenant::create([
'id' => 'acme',
]);
expect(tenancy()->initialized)->toBeFalse();
$this->assertFalse(tenancy()->initialized);
pest()
->get('/acme/foo/abc/xyz')
->assertContent('abc + xyz');
$this
->get('/acme/foo/abc/xyz')
->assertContent('abc + xyz');
expect(tenancy()->initialized)->toBeTrue();
expect(tenant('id'))->toBe('acme');
});
$this->assertTrue(tenancy()->initialized);
$this->assertSame('acme', tenant('id'));
}
test('exception is thrown when tenant cannot be identified by path', function () {
pest()->expectException(TenantCouldNotBeIdentifiedByPathException::class);
/** @test */
public function exception_is_thrown_when_tenant_cannot_be_identified_by_path()
{
$this->expectException(TenantCouldNotBeIdentifiedByPathException::class);
$this
->withoutExceptionHandling()
->get('/acme/foo/abc/xyz');
$this
->withoutExceptionHandling()
->get('/acme/foo/abc/xyz');
expect(tenancy()->initialized)->toBeFalse();
});
$this->assertFalse(tenancy()->initialized);
}
test('onfail logic can be customized', function () {
InitializeTenancyByPath::$onFail = function () {
return 'foo';
};
/** @test */
public function onfail_logic_can_be_customized()
{
InitializeTenancyByPath::$onFail = function () {
return 'foo';
};
pest()
->get('/acme/foo/abc/xyz')
->assertContent('foo');
});
$this
->get('/acme/foo/abc/xyz')
->assertContent('foo');
}
/** @test */
public function an_exception_is_thrown_when_the_routes_first_parameter_is_not_tenant()
{
Route::group([
// 'prefix' => '/{tenant}', -- intentionally commented
'middleware' => InitializeTenancyByPath::class,
], function () {
Route::get('/bar/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
test('an exception is thrown when the routes first parameter is not tenant', function () {
Route::group([
// 'prefix' => '/{tenant}', -- intentionally commented
'middleware' => InitializeTenancyByPath::class,
], function () {
Route::get('/bar/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
});
Tenant::create([
'id' => 'acme',
]);
Tenant::create([
'id' => 'acme',
]);
$this->expectException(RouteIsMissingTenantParameterException::class);
pest()->expectException(RouteIsMissingTenantParameterException::class);
$this
->withoutExceptionHandling()
->get('/bar/foo/bar');
}
$this
->withoutExceptionHandling()
->get('/bar/foo/bar');
});
/** @test */
public function tenant_parameter_name_can_be_customized()
{
PathTenantResolver::$tenantParameterName = 'team';
test('tenant parameter name can be customized', function () {
PathTenantResolver::$tenantParameterName = 'team';
Route::group([
'prefix' => '/{team}',
'middleware' => InitializeTenancyByPath::class,
], function () {
Route::get('/bar/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
Route::group([
'prefix' => '/{team}',
'middleware' => InitializeTenancyByPath::class,
], function () {
Route::get('/bar/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
});
Tenant::create([
'id' => 'acme',
]);
Tenant::create([
'id' => 'acme',
]);
$this
->get('/acme/bar/abc/xyz')
->assertContent('abc + xyz');
pest()
->get('/acme/bar/abc/xyz')
->assertContent('abc + xyz');
// Parameter for resolver is changed, so the /{tenant}/foo route will no longer work.
$this->expectException(RouteIsMissingTenantParameterException::class);
// Parameter for resolver is changed, so the /{tenant}/foo route will no longer work.
pest()->expectException(RouteIsMissingTenantParameterException::class);
$this
->withoutExceptionHandling()
->get('/acme/foo/abc/xyz');
}
}
$this
->withoutExceptionHandling()
->get('/acme/foo/abc/xyz');
});

10
tests/Pest.php Normal file
View file

@ -0,0 +1,10 @@
<?php
use Stancl\Tenancy\Tests\TestCase;
uses(TestCase::class)->in(__DIR__);
function pest(): TestCase
{
return Pest\TestSuite::getInstance()->test;
}

322
tests/QueueTest.php
View file

@ -2,122 +2,226 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\Events\JobProcessing;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Event;
use Spatie\Valuestore\Valuestore;
use Stancl\Tenancy\Bootstrappers\QueueTenancyBootstrapper;
use Illuminate\Support\Facades\DB;
use Stancl\Tenancy\Tests\Etc\User;
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Schema;
use Stancl\Tenancy\Events\TenancyEnded;
use Stancl\Tenancy\Jobs\CreateDatabase;
use Stancl\Tenancy\Events\TenantCreated;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Queue\Events\JobProcessed;
use Illuminate\Queue\Events\JobProcessing;
use Stancl\Tenancy\Events\TenancyInitialized;
use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\Bootstrappers\QueueTenancyBootstrapper;
use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
class QueueTest extends TestCase
beforeEach(function () {
$this->mockConsoleOutput = false;
config([
'tenancy.bootstrappers' => [
QueueTenancyBootstrapper::class,
DatabaseTenancyBootstrapper::class,
],
'queue.default' => 'redis',
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
createValueStore();
});
afterEach(function () {
pest()->valuestore->flush();
});
test('tenant id is passed to tenant queues', function () {
config(['queue.default' => 'sync']);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
Event::fake([JobProcessing::class, JobProcessed::class]);
dispatch(new TestJob(pest()->valuestore));
Event::assertDispatched(JobProcessing::class, function ($event) {
return $event->job->payload()['tenant_id'] === tenant('id');
});
});
test('tenant id is not passed to central queues', function () {
$tenant = Tenant::create();
tenancy()->initialize($tenant);
Event::fake();
config(['queue.connections.central' => [
'driver' => 'sync',
'central' => true,
]]);
dispatch(new TestJob(pest()->valuestore))->onConnection('central');
Event::assertDispatched(JobProcessing::class, function ($event) {
return ! isset($event->job->payload()['tenant_id']);
});
});
test('tenancy is initialized inside queues', function (bool $shouldEndTenancy) {
withTenantDatabases();
withFailedJobs();
$tenant = Tenant::create();
tenancy()->initialize($tenant);
withUsers();
$user = User::create(['name' => 'Foo', 'email' => 'foo@bar.com', 'password' => 'secret']);
pest()->valuestore->put('userName', 'Bar');
dispatch(new TestJob(pest()->valuestore, $user));
expect(pest()->valuestore->has('tenant_id'))->toBeFalse();
if ($shouldEndTenancy) {
tenancy()->end();
}
pest()->artisan('queue:work --once');
expect(DB::connection('central')->table('failed_jobs')->count())->toBe(0);
expect(pest()->valuestore->get('tenant_id'))->toBe('The current tenant id is: ' . $tenant->id);
$tenant->run(function () use ($user) {
expect($user->fresh()->name)->toBe('Bar');
});
})->with([true, false]);;
test('tenancy is initialized when retrying jobs', function (bool $shouldEndTenancy) {
withFailedJobs();
withTenantDatabases();
$tenant = Tenant::create();
tenancy()->initialize($tenant);
withUsers();
$user = User::create(['name' => 'Foo', 'email' => 'foo@bar.com', 'password' => 'secret']);
pest()->valuestore->put('userName', 'Bar');
pest()->valuestore->put('shouldFail', true);
dispatch(new TestJob(pest()->valuestore, $user));
expect(pest()->valuestore->has('tenant_id'))->toBeFalse();
if ($shouldEndTenancy) {
tenancy()->end();
}
pest()->artisan('queue:work --once');
expect(DB::connection('central')->table('failed_jobs')->count())->toBe(1);
expect(pest()->valuestore->get('tenant_id'))->toBeNull(); // job failed
pest()->artisan('queue:retry all');
pest()->artisan('queue:work --once');
expect(DB::connection('central')->table('failed_jobs')->count())->toBe(0);
expect(pest()->valuestore->get('tenant_id'))->toBe('The current tenant id is: ' . $tenant->id); // job succeeded
$tenant->run(function () use ($user) {
expect($user->fresh()->name)->toBe('Bar');
});
})->with([true, false]);
test('the tenant used by the job doesnt change when the current tenant changes', function () {
$tenant1 = Tenant::create([
'id' => 'acme',
]);
tenancy()->initialize($tenant1);
dispatch(new TestJob(pest()->valuestore));
$tenant2 = Tenant::create([
'id' => 'foobar',
]);
tenancy()->initialize($tenant2);
expect(pest()->valuestore->has('tenant_id'))->toBeFalse();
pest()->artisan('queue:work --once');
expect(pest()->valuestore->get('tenant_id'))->toBe('The current tenant id is: acme');
});
function createValueStore(): void
{
public $mockConsoleOutput = false;
$valueStorePath = __DIR__ . '/Etc/tmp/queuetest.json';
/** @var Valuestore */
protected $valuestore;
if (! file_exists($valueStorePath)) {
// The directory sometimes goes missing as well when the file is deleted in git
if (! is_dir(__DIR__ . '/Etc/tmp')) {
mkdir(__DIR__ . '/Etc/tmp');
}
public function setUp(): void
{
parent::setUp();
config([
'tenancy.bootstrappers' => [
QueueTenancyBootstrapper::class,
],
'queue.default' => 'redis',
]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
$this->valuestore = Valuestore::make(__DIR__ . '/Etc/tmp/queuetest.json')->flush();
file_put_contents($valueStorePath, '');
}
/** @test */
public function tenant_id_is_passed_to_tenant_queues()
{
config(['queue.default' => 'sync']);
pest()->valuestore = Valuestore::make($valueStorePath)->flush();
}
$tenant = Tenant::create();
function withFailedJobs()
{
Schema::connection('central')->create('failed_jobs', function (Blueprint $table) {
$table->increments('id');
$table->string('uuid')->unique();
$table->text('connection');
$table->text('queue');
$table->longText('payload');
$table->longText('exception');
$table->timestamp('failed_at')->useCurrent();
});
}
tenancy()->initialize($tenant);
function withUsers()
{
Schema::create('users', function (Blueprint $table) {
$table->increments('id');
$table->string('name');
$table->string('email')->unique();
$table->string('password');
$table->rememberToken();
$table->timestamps();
});
}
Event::fake([JobProcessing::class]);
dispatch(new TestJob($this->valuestore));
Event::assertDispatched(JobProcessing::class, function ($event) {
return $event->job->payload()['tenant_id'] === tenant('id');
});
}
/** @test */
public function tenant_id_is_not_passed_to_central_queues()
{
$tenant = Tenant::create();
tenancy()->initialize($tenant);
Event::fake();
config(['queue.connections.central' => [
'driver' => 'sync',
'central' => true,
]]);
dispatch(new TestJob($this->valuestore))->onConnection('central');
Event::assertDispatched(JobProcessing::class, function ($event) {
return ! isset($event->job->payload()['tenant_id']);
});
}
/** @test */
public function tenancy_is_initialized_inside_queues()
{
$tenant = Tenant::create([
'id' => 'acme',
]);
tenancy()->initialize($tenant);
dispatch(new TestJob($this->valuestore));
$this->assertFalse($this->valuestore->has('tenant_id'));
$this->artisan('queue:work --once');
$this->assertSame('The current tenant id is: acme', $this->valuestore->get('tenant_id'));
}
/** @test */
public function the_tenant_used_by_the_job_doesnt_change_when_the_current_tenant_changes()
{
$tenant1 = Tenant::create([
'id' => 'acme',
]);
tenancy()->initialize($tenant1);
dispatch(new TestJob($this->valuestore));
$tenant2 = Tenant::create([
'id' => 'foobar',
]);
tenancy()->initialize($tenant2);
$this->assertFalse($this->valuestore->has('tenant_id'));
$this->artisan('queue:work --once');
$this->assertSame('The current tenant id is: acme', $this->valuestore->get('tenant_id'));
}
function withTenantDatabases()
{
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
}
class TestJob implements ShouldQueue
@ -127,13 +231,31 @@ class TestJob implements ShouldQueue
/** @var Valuestore */
protected $valuestore;
public function __construct(Valuestore $valuestore)
/** @var User|null */
protected $user;
public function __construct(Valuestore $valuestore, User $user = null)
{
$this->valuestore = $valuestore;
$this->user = $user;
}
public function handle()
{
if ($this->valuestore->get('shouldFail')) {
$this->valuestore->put('shouldFail', false);
throw new Exception('failing');
}
if ($this->user) {
assert($this->user->getConnectionName() === 'tenant');
}
$this->valuestore->put('tenant_id', 'The current tenant id is: ' . tenant('id'));
if ($userName = $this->valuestore->get('userName')) {
$this->user->update(['name' => $userName]);
}
}
}

85
tests/RequestDataIdentificationTest.php
View file

@ -2,64 +2,49 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Middleware\InitializeTenancyByRequestData;
use Stancl\Tenancy\Tests\Etc\Tenant;
class RequestDataIdentificationTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
beforeEach(function () {
config([
'tenancy.central_domains' => [
'localhost',
],
]);
config([
'tenancy.central_domains' => [
'localhost',
],
]);
Route::middleware(InitializeTenancyByRequestData::class)->get('/test', function () {
return 'Tenant id: ' . tenant('id');
});
});
Route::middleware(InitializeTenancyByRequestData::class)->get('/test', function () {
return 'Tenant id: ' . tenant('id');
});
}
afterEach(function () {
InitializeTenancyByRequestData::$header = 'X-Tenant';
InitializeTenancyByRequestData::$queryParameter = 'tenant';
});
public function tearDown(): void
{
InitializeTenancyByRequestData::$header = 'X-Tenant';
InitializeTenancyByRequestData::$queryParameter = 'tenant';
test('header identification works', function () {
InitializeTenancyByRequestData::$header = 'X-Tenant';
$tenant = Tenant::create();
$tenant2 = Tenant::create();
parent::tearDown();
}
$this
->withoutExceptionHandling()
->get('test', [
'X-Tenant' => $tenant->id,
])
->assertSee($tenant->id);
});
/** @test */
public function header_identification_works()
{
InitializeTenancyByRequestData::$header = 'X-Tenant';
$tenant = Tenant::create();
$tenant2 = Tenant::create();
test('query parameter identification works', function () {
InitializeTenancyByRequestData::$header = null;
InitializeTenancyByRequestData::$queryParameter = 'tenant';
$this
->withoutExceptionHandling()
->get('test', [
'X-Tenant' => $tenant->id,
])
->assertSee($tenant->id);
}
$tenant = Tenant::create();
$tenant2 = Tenant::create();
/** @test */
public function query_parameter_identification_works()
{
InitializeTenancyByRequestData::$header = null;
InitializeTenancyByRequestData::$queryParameter = 'tenant';
$tenant = Tenant::create();
$tenant2 = Tenant::create();
$this
->withoutExceptionHandling()
->get('test?tenant=' . $tenant->id)
->assertSee($tenant->id);
}
}
$this
->withoutExceptionHandling()
->get('test?tenant=' . $tenant->id)
->assertSee($tenant->id);
});

924
tests/ResourceSyncingTest.php
View file

File diff suppressed because it is too large Load diff

98
tests/ScopeSessionsTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Session\Middleware\StartSession;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Route;
@ -13,69 +11,57 @@ use Stancl\Tenancy\Middleware\InitializeTenancyBySubdomain;
use Stancl\Tenancy\Middleware\ScopeSessions;
use Stancl\Tenancy\Tests\Etc\Tenant;
class ScopeSessionsTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
Route::group([
'middleware' => [StartSession::class, InitializeTenancyBySubdomain::class, ScopeSessions::class],
], function () {
Route::get('/foo', function () {
return 'true';
});
beforeEach(function () {
Route::group([
'middleware' => [StartSession::class, InitializeTenancyBySubdomain::class, ScopeSessions::class],
], function () {
Route::get('/foo', function () {
return 'true';
});
});
Event::listen(TenantCreated::class, function (TenantCreated $event) {
$tenant = $event->tenant;
Event::listen(TenantCreated::class, function (TenantCreated $event) {
$tenant = $event->tenant;
/** @var Tenant $tenant */
$tenant->domains()->create([
'domain' => $tenant->id,
]);
});
}
/** @test */
public function tenant_id_is_auto_added_to_session_if_its_missing()
{
$tenant = Tenant::create([
'id' => 'acme',
/** @var Tenant $tenant */
$tenant->domains()->create([
'domain' => $tenant->id,
]);
});
});
$this->get('http://acme.localhost/foo')
->assertSessionHas(ScopeSessions::$tenantIdKey, 'acme');
}
test('tenant id is auto added to session if its missing', function () {
$tenant = Tenant::create([
'id' => 'acme',
]);
/** @test */
public function changing_tenant_id_in_session_will_abort_the_request()
{
$tenant = Tenant::create([
'id' => 'acme',
]);
pest()->get('http://acme.localhost/foo')
->assertSessionHas(ScopeSessions::$tenantIdKey, 'acme');
});
$this->get('http://acme.localhost/foo')
->assertSuccessful();
test('changing tenant id in session will abort the request', function () {
$tenant = Tenant::create([
'id' => 'acme',
]);
session()->put(ScopeSessions::$tenantIdKey, 'foobar');
pest()->get('http://acme.localhost/foo')
->assertSuccessful();
$this->get('http://acme.localhost/foo')
->assertStatus(403);
}
session()->put(ScopeSessions::$tenantIdKey, 'foobar');
/** @test */
public function an_exception_is_thrown_when_the_middleware_is_executed_before_tenancy_is_initialized()
{
Route::get('/bar', function () {
return true;
})->middleware([StartSession::class, ScopeSessions::class]);
pest()->get('http://acme.localhost/foo')
->assertStatus(403);
});
$tenant = Tenant::create([
'id' => 'acme',
]);
test('an exception is thrown when the middleware is executed before tenancy is initialized', function () {
Route::get('/bar', function () {
return true;
})->middleware([StartSession::class, ScopeSessions::class]);
$this->expectException(TenancyNotInitializedException::class);
$this->withoutExceptionHandling()->get('http://acme.localhost/bar');
}
}
$tenant = Tenant::create([
'id' => 'acme',
]);
pest()->expectException(TenancyNotInitializedException::class);
pest()->withoutExceptionHandling()->get('http://acme.localhost/bar');
});

557
tests/SingleDatabaseTenancyTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\QueryException;
use Illuminate\Database\Schema\Blueprint;
@ -14,309 +12,293 @@ use Stancl\Tenancy\Database\Concerns\BelongsToTenant;
use Stancl\Tenancy\Database\Concerns\HasScopedValidationRules;
use Stancl\Tenancy\Tests\Etc\Tenant as TestTenant;
class SingleDatabaseTenancyTest extends TestCase
beforeEach(function () {
BelongsToTenant::$tenantIdColumn = 'tenant_id';
Schema::create('posts', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
$table->string('tenant_id');
$table->foreign('tenant_id')->references('id')->on('tenants')->onUpdate('cascade')->onDelete('cascade');
});
Schema::create('comments', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
$table->unsignedInteger('post_id');
$table->foreign('post_id')->references('id')->on('posts')->onUpdate('cascade')->onDelete('cascade');
});
config(['tenancy.tenant_model' => Tenant::class]);
});
test('primary models are scoped to the current tenant', function () {
primaryModelsScopedToCurrentTenant();
});
test('primary models are not scoped in the central context', function () {
primaryModelsScopedToCurrentTenant();
tenancy()->end();
expect(Post::count())->toBe(2);
});
test('secondary models are scoped to the current tenant when accessed via primary model', function () {
secondaryModelsAreScopedToCurrentTenant();
});
test('secondary models are not scoped to the current tenant when accessed directly', function () {
secondaryModelsAreScopedToCurrentTenant();
// We're in acme context
expect(tenant('id'))->toBe('acme');
expect(Comment::count())->toBe(2);
});
test('secondary models a r e scoped to the current tenant when accessed directly and parent relationship traitis used', function () {
$acme = Tenant::create([
'id' => 'acme',
]);
$acme->run(function () {
$post = Post::create(['text' => 'Foo']);
$post->scoped_comments()->create(['text' => 'Comment Text']);
expect(Post::count())->toBe(1);
expect(ScopedComment::count())->toBe(1);
});
$foobar = Tenant::create([
'id' => 'foobar',
]);
$foobar->run(function () {
expect(Post::count())->toBe(0);
expect(ScopedComment::count())->toBe(0);
$post = Post::create(['text' => 'Bar']);
$post->scoped_comments()->create(['text' => 'Comment Text 2']);
expect(Post::count())->toBe(1);
expect(ScopedComment::count())->toBe(1);
});
// Global context
expect(ScopedComment::count())->toBe(2);
});
test('secondary models are not scoped in the central context', function () {
secondaryModelsAreScopedToCurrentTenant();
tenancy()->end();
expect(Comment::count())->toBe(2);
});
test('global models are not scoped at all', function () {
Schema::create('global_resources', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
});
GlobalResource::create(['text' => 'First']);
GlobalResource::create(['text' => 'Second']);
$acme = Tenant::create([
'id' => 'acme',
]);
$acme->run(function () {
expect(GlobalResource::count())->toBe(2);
GlobalResource::create(['text' => 'Third']);
GlobalResource::create(['text' => 'Fourth']);
});
expect(GlobalResource::count())->toBe(4);
});
test('tenant id and relationship is auto added when creating primary resources in tenant context', function () {
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
$post = Post::create(['text' => 'Foo']);
expect($post->tenant_id)->toBe('acme');
expect($post->relationLoaded('tenant'))->toBeTrue();
expect($post->tenant)->toBe($acme);
expect($post->tenant)->toBe(tenant());
});
test('tenant id is not auto added when creating primary resources in central context', function () {
pest()->expectException(QueryException::class);
Post::create(['text' => 'Foo']);
});
test('tenant id column name can be customized', function () {
BelongsToTenant::$tenantIdColumn = 'team_id';
Schema::drop('comments');
Schema::drop('posts');
Schema::create('posts', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
$table->string('team_id');
$table->foreign('team_id')->references('id')->on('tenants')->onUpdate('cascade')->onDelete('cascade');
});
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
$post = Post::create(['text' => 'Foo']);
expect($post->team_id)->toBe('acme');
// ======================================
// foobar context
tenancy()->initialize($foobar = Tenant::create([
'id' => 'foobar',
]));
$post = Post::create(['text' => 'Bar']);
expect($post->team_id)->toBe('foobar');
$post = Post::first();
expect($post->team_id)->toBe('foobar');
// ======================================
// acme context again
tenancy()->initialize($acme);
$post = Post::first();
expect($post->team_id)->toBe('acme');
// Assert foobar models are inaccessible in acme context
expect(Post::count())->toBe(1);
});
test('the model returned by the tenant helper has unique and exists validation rules', function () {
Schema::table('posts', function (Blueprint $table) {
$table->string('slug')->nullable();
$table->unique(['tenant_id', 'slug']);
});
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
Post::create(['text' => 'Foo', 'slug' => 'foo']);
$data = ['text' => 'Foo 2', 'slug' => 'foo'];
$uniqueFails = Validator::make($data, [
'slug' => 'unique:posts',
])->fails();
$existsFails = Validator::make($data, [
'slug' => 'exists:posts',
])->fails();
// Assert that 'unique' and 'exists' aren't scoped by default
// pest()->assertFalse($uniqueFails); // todo get these two assertions to pass. for some reason, the validator is passing for both 'unique' and 'exists'
// pest()->assertTrue($existsFails); // todo get these two assertions to pass. for some reason, the validator is passing for both 'unique' and 'exists'
$uniqueFails = Validator::make($data, [
'slug' => tenant()->unique('posts'),
])->fails();
$existsFails = Validator::make($data, [
'slug' => tenant()->exists('posts'),
])->fails();
// Assert that tenant()->unique() and tenant()->exists() are scoped
expect($uniqueFails)->toBeTrue();
expect($existsFails)->toBeFalse();
});
// todo@tests
function primaryModelsScopedToCurrentTenant()
{
public function setUp(): void
{
parent::setUp();
// acme context
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
BelongsToTenant::$tenantIdColumn = 'tenant_id';
$post = Post::create(['text' => 'Foo']);
Schema::create('posts', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
expect($post->tenant_id)->toBe('acme');
expect($post->tenant->id)->toBe('acme');
$table->string('tenant_id');
$post = Post::first();
$table->foreign('tenant_id')->references('id')->on('tenants')->onUpdate('cascade')->onDelete('cascade');
});
expect($post->tenant_id)->toBe('acme');
expect($post->tenant->id)->toBe('acme');
Schema::create('comments', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
// ======================================
// foobar context
tenancy()->initialize($foobar = Tenant::create([
'id' => 'foobar',
]));
$table->unsignedInteger('post_id');
$post = Post::create(['text' => 'Bar']);
$table->foreign('post_id')->references('id')->on('posts')->onUpdate('cascade')->onDelete('cascade');
});
expect($post->tenant_id)->toBe('foobar');
expect($post->tenant->id)->toBe('foobar');
config(['tenancy.tenant_model' => Tenant::class]);
}
$post = Post::first();
/** @test */
public function primary_models_are_scoped_to_the_current_tenant()
{
// acme context
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
expect($post->tenant_id)->toBe('foobar');
expect($post->tenant->id)->toBe('foobar');
$post = Post::create(['text' => 'Foo']);
// ======================================
// acme context again
$this->assertSame('acme', $post->tenant_id);
$this->assertSame('acme', $post->tenant->id);
tenancy()->initialize($acme);
$post = Post::first();
$post = Post::first();
expect($post->tenant_id)->toBe('acme');
expect($post->tenant->id)->toBe('acme');
$this->assertSame('acme', $post->tenant_id);
$this->assertSame('acme', $post->tenant->id);
// Assert foobar models are inaccessible in acme context
expect(Post::count())->toBe(1);
}
// ======================================
// foobar context
tenancy()->initialize($foobar = Tenant::create([
'id' => 'foobar',
]));
// todo@tests
function secondaryModelsAreScopedToCurrentTenant()
{
// acme context
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
$post = Post::create(['text' => 'Bar']);
$post = Post::create(['text' => 'Foo']);
$post->comments()->create(['text' => 'Comment text']);
$this->assertSame('foobar', $post->tenant_id);
$this->assertSame('foobar', $post->tenant->id);
// ================
// foobar context
tenancy()->initialize($foobar = Tenant::create([
'id' => 'foobar',
]));
$post = Post::first();
$post = Post::create(['text' => 'Bar']);
$post->comments()->create(['text' => 'Comment text 2']);
$this->assertSame('foobar', $post->tenant_id);
$this->assertSame('foobar', $post->tenant->id);
// ======================================
// acme context again
tenancy()->initialize($acme);
$post = Post::first();
$this->assertSame('acme', $post->tenant_id);
$this->assertSame('acme', $post->tenant->id);
// Assert foobar models are inaccessible in acme context
$this->assertSame(1, Post::count());
}
/** @test */
public function primary_models_are_not_scoped_in_the_central_context()
{
$this->primary_models_are_scoped_to_the_current_tenant();
tenancy()->end();
$this->assertSame(2, Post::count());
}
/** @test */
public function secondary_models_are_scoped_to_the_current_tenant_when_accessed_via_primary_model()
{
// acme context
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
$post = Post::create(['text' => 'Foo']);
$post->comments()->create(['text' => 'Comment text']);
// ================
// foobar context
tenancy()->initialize($foobar = Tenant::create([
'id' => 'foobar',
]));
$post = Post::create(['text' => 'Bar']);
$post->comments()->create(['text' => 'Comment text 2']);
// ================
// acme context again
tenancy()->initialize($acme);
$this->assertSame(1, Post::count());
$this->assertSame(1, Post::first()->comments->count());
}
/** @test */
public function secondary_models_are_NOT_scoped_to_the_current_tenant_when_accessed_directly()
{
$this->secondary_models_are_scoped_to_the_current_tenant_when_accessed_via_primary_model();
// We're in acme context
$this->assertSame('acme', tenant('id'));
$this->assertSame(2, Comment::count());
}
/** @test */
public function secondary_models_ARE_scoped_to_the_current_tenant_when_accessed_directly_AND_PARENT_RELATIONSHIP_TRAIT_IS_USED()
{
$acme = Tenant::create([
'id' => 'acme',
]);
$acme->run(function () {
$post = Post::create(['text' => 'Foo']);
$post->scoped_comments()->create(['text' => 'Comment Text']);
$this->assertSame(1, Post::count());
$this->assertSame(1, ScopedComment::count());
});
$foobar = Tenant::create([
'id' => 'foobar',
]);
$foobar->run(function () {
$this->assertSame(0, Post::count());
$this->assertSame(0, ScopedComment::count());
$post = Post::create(['text' => 'Bar']);
$post->scoped_comments()->create(['text' => 'Comment Text 2']);
$this->assertSame(1, Post::count());
$this->assertSame(1, ScopedComment::count());
});
// Global context
$this->assertSame(2, ScopedComment::count());
}
/** @test */
public function secondary_models_are_NOT_scoped_in_the_central_context()
{
$this->secondary_models_are_scoped_to_the_current_tenant_when_accessed_via_primary_model();
tenancy()->end();
$this->assertSame(2, Comment::count());
}
/** @test */
public function global_models_are_not_scoped_at_all()
{
Schema::create('global_resources', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
});
GlobalResource::create(['text' => 'First']);
GlobalResource::create(['text' => 'Second']);
$acme = Tenant::create([
'id' => 'acme',
]);
$acme->run(function () {
$this->assertSame(2, GlobalResource::count());
GlobalResource::create(['text' => 'Third']);
GlobalResource::create(['text' => 'Fourth']);
});
$this->assertSame(4, GlobalResource::count());
}
/** @test */
public function tenant_id_and_relationship_is_auto_added_when_creating_primary_resources_in_tenant_context()
{
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
$post = Post::create(['text' => 'Foo']);
$this->assertSame('acme', $post->tenant_id);
$this->assertTrue($post->relationLoaded('tenant'));
$this->assertSame($acme, $post->tenant);
$this->assertSame(tenant(), $post->tenant);
}
/** @test */
public function tenant_id_is_not_auto_added_when_creating_primary_resources_in_central_context()
{
$this->expectException(QueryException::class);
Post::create(['text' => 'Foo']);
}
/** @test */
public function tenant_id_column_name_can_be_customized()
{
BelongsToTenant::$tenantIdColumn = 'team_id';
Schema::drop('comments');
Schema::drop('posts');
Schema::create('posts', function (Blueprint $table) {
$table->increments('id');
$table->string('text');
$table->string('team_id');
$table->foreign('team_id')->references('id')->on('tenants')->onUpdate('cascade')->onDelete('cascade');
});
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
$post = Post::create(['text' => 'Foo']);
$this->assertSame('acme', $post->team_id);
// ======================================
// foobar context
tenancy()->initialize($foobar = Tenant::create([
'id' => 'foobar',
]));
$post = Post::create(['text' => 'Bar']);
$this->assertSame('foobar', $post->team_id);
$post = Post::first();
$this->assertSame('foobar', $post->team_id);
// ======================================
// acme context again
tenancy()->initialize($acme);
$post = Post::first();
$this->assertSame('acme', $post->team_id);
// Assert foobar models are inaccessible in acme context
$this->assertSame(1, Post::count());
}
/** @test */
public function the_model_returned_by_the_tenant_helper_has_unique_and_exists_validation_rules()
{
Schema::table('posts', function (Blueprint $table) {
$table->string('slug')->nullable();
$table->unique(['tenant_id', 'slug']);
});
tenancy()->initialize($acme = Tenant::create([
'id' => 'acme',
]));
Post::create(['text' => 'Foo', 'slug' => 'foo']);
$data = ['text' => 'Foo 2', 'slug' => 'foo'];
$uniqueFails = Validator::make($data, [
'slug' => 'unique:posts',
])->fails();
$existsFails = Validator::make($data, [
'slug' => 'exists:posts',
])->fails();
// Assert that 'unique' and 'exists' aren't scoped by default
// $this->assertFalse($uniqueFails); // todo get these two assertions to pass. for some reason, the validator is passing for both 'unique' and 'exists'
// $this->assertTrue($existsFails); // todo get these two assertions to pass. for some reason, the validator is passing for both 'unique' and 'exists'
$uniqueFails = Validator::make($data, [
'slug' => tenant()->unique('posts'),
])->fails();
$existsFails = Validator::make($data, [
'slug' => tenant()->exists('posts'),
])->fails();
// Assert that tenant()->unique() and tenant()->exists() are scoped
$this->assertTrue($uniqueFails);
$this->assertFalse($existsFails);
}
// ================
// acme context again
tenancy()->initialize($acme);
expect(Post::count())->toBe(1);
expect(Post::first()->comments->count())->toBe(1);
}
class Tenant extends TestTenant
@ -329,6 +311,7 @@ class Post extends Model
use BelongsToTenant;
protected $guarded = [];
public $timestamps = false;
public function comments()
@ -345,6 +328,7 @@ class Post extends Model
class Comment extends Model
{
protected $guarded = [];
public $timestamps = false;
public function post()
@ -368,5 +352,6 @@ class ScopedComment extends Comment
class GlobalResource extends Model
{
protected $guarded = [];
public $timestamps = false;
}

204
tests/SubdomainTest.php
View file

@ -2,151 +2,129 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Database\Concerns\HasDomains;
use Stancl\Tenancy\Database\Models;
use Stancl\Tenancy\Exceptions\NotASubdomainException;
use Stancl\Tenancy\Middleware\InitializeTenancyBySubdomain;
use Stancl\Tenancy\Database\Models;
class SubdomainTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
beforeEach(function () {
// Global state cleanup after some tests
InitializeTenancyBySubdomain::$onFail = null;
// Global state cleanup after some tests
InitializeTenancyBySubdomain::$onFail = null;
Route::group([
'middleware' => InitializeTenancyBySubdomain::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
Route::group([
'middleware' => InitializeTenancyBySubdomain::class,
], function () {
Route::get('/foo/{a}/{b}', function ($a, $b) {
return "$a + $b";
});
});
config(['tenancy.tenant_model' => SubdomainTenant::class]);
}
config(['tenancy.tenant_model' => SubdomainTenant::class]);
});
/** @test */
public function tenant_can_be_identified_by_subdomain()
{
$tenant = SubdomainTenant::create([
'id' => 'acme',
]);
test('tenant can be identified by subdomain', function () {
$tenant = SubdomainTenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'foo',
]);
$tenant->domains()->create([
'domain' => 'foo',
]);
$this->assertFalse(tenancy()->initialized);
expect(tenancy()->initialized)->toBeFalse();
$this
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
pest()
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('abc + xyz');
$this->assertTrue(tenancy()->initialized);
$this->assertSame('acme', tenant('id'));
}
expect(tenancy()->initialized)->toBeTrue();
expect(tenant('id'))->toBe('acme');
});
/** @test */
public function onfail_logic_can_be_customized()
{
InitializeTenancyBySubdomain::$onFail = function () {
return 'foo';
};
test('onfail logic can be customized', function () {
InitializeTenancyBySubdomain::$onFail = function () {
return 'foo';
};
$this
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('foo');
}
pest()
->get('http://foo.localhost/foo/abc/xyz')
->assertSee('foo');
});
/** @test */
public function localhost_is_not_a_valid_subdomain()
{
$this->expectException(NotASubdomainException::class);
test('localhost is not a valid subdomain', function () {
pest()->expectException(NotASubdomainException::class);
$this
->withoutExceptionHandling()
->get('http://localhost/foo/abc/xyz');
}
$this
->withoutExceptionHandling()
->get('http://localhost/foo/abc/xyz');
});
/** @test */
public function ip_address_is_not_a_valid_subdomain()
{
$this->expectException(NotASubdomainException::class);
test('ip address is not a valid subdomain', function () {
pest()->expectException(NotASubdomainException::class);
$this
->withoutExceptionHandling()
->get('http://127.0.0.1/foo/abc/xyz');
}
$this
->withoutExceptionHandling()
->get('http://127.0.0.1/foo/abc/xyz');
});
/** @test */
public function oninvalidsubdomain_logic_can_be_customized()
{
// in this case, we need to return a response instance
// since a string would be treated as the subdomain
InitializeTenancyBySubdomain::$onFail = function ($e) {
if ($e instanceof NotASubdomainException) {
return response('foo custom invalid subdomain handler');
}
test('oninvalidsubdomain logic can be customized', function () {
// in this case, we need to return a response instance
// since a string would be treated as the subdomain
InitializeTenancyBySubdomain::$onFail = function ($e) {
if ($e instanceof NotASubdomainException) {
return response('foo custom invalid subdomain handler');
}
throw $e;
};
throw $e;
};
$this
->withoutExceptionHandling()
->get('http://127.0.0.1/foo/abc/xyz')
->assertSee('foo custom invalid subdomain handler');
}
$this
->withoutExceptionHandling()
->get('http://127.0.0.1/foo/abc/xyz')
->assertSee('foo custom invalid subdomain handler');
});
/** @test */
public function we_cant_use_a_subdomain_that_doesnt_belong_to_our_central_domains()
{
config(['tenancy.central_domains' => [
'127.0.0.1',
// not 'localhost'
]]);
test('we cant use a subdomain that doesnt belong to our central domains', function () {
config(['tenancy.central_domains' => [
'127.0.0.1',
// not 'localhost'
]]);
$tenant = SubdomainTenant::create([
'id' => 'acme',
]);
$tenant = SubdomainTenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'foo',
]);
$tenant->domains()->create([
'domain' => 'foo',
]);
$this->expectException(NotASubdomainException::class);
pest()->expectException(NotASubdomainException::class);
$this
->withoutExceptionHandling()
->get('http://foo.localhost/foo/abc/xyz');
}
$this
->withoutExceptionHandling()
->get('http://foo.localhost/foo/abc/xyz');
});
/** @test */
public function central_domain_is_not_a_subdomain()
{
config(['tenancy.central_domains' => [
'localhost',
]]);
test('central domain is not a subdomain', function () {
config(['tenancy.central_domains' => [
'localhost',
]]);
$tenant = SubdomainTenant::create([
'id' => 'acme',
]);
$tenant = SubdomainTenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'acme',
]);
$this->expectException(NotASubdomainException::class);
pest()->expectException(NotASubdomainException::class);
$this
->withoutExceptionHandling()
->get('http://localhost/foo/abc/xyz');
}
}
$this
->withoutExceptionHandling()
->get('http://localhost/foo/abc/xyz');
});
class SubdomainTenant extends Models\Tenant
{

201
tests/TenantAssetTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Route;
use Illuminate\Support\Facades\Storage;
@ -15,115 +13,94 @@ use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
use Stancl\Tenancy\Middleware\InitializeTenancyByRequestData;
use Stancl\Tenancy\Tests\Etc\Tenant;
class TenantAssetTest extends TestCase
beforeEach(function () {
config(['tenancy.bootstrappers' => [
FilesystemTenancyBootstrapper::class,
]]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
});
afterEach(function () {
// Cleanup
TenantAssetsController::$tenancyMiddleware = InitializeTenancyByDomain::class;
});
test('asset can be accessed using the url returned by the tenant asset helper', function () {
TenantAssetsController::$tenancyMiddleware = InitializeTenancyByRequestData::class;
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$filename = 'testfile' . pest()->randomString(10);
Storage::disk('public')->put($filename, 'bar');
$path = storage_path("app/public/$filename");
// response()->file() returns BinaryFileResponse whose content is
// inaccessible via getContent, so ->assertSee() can't be used
expect($path)->toBeFile();
$response = pest()->get(tenant_asset($filename), [
'X-Tenant' => $tenant->id,
]);
$response->assertSuccessful();
$f = fopen($path, 'r');
$content = fread($f, filesize($path));
fclose($f);
expect($content)->toBe('bar');
});
test('asset helper returns a link to tenant asset controller when asset url is null', function () {
config(['app.asset_url' => null]);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
expect(asset('foo'))->toBe(route('stancl.tenancy.asset', ['path' => 'foo']));
});
test('asset helper returns a link to an external url when asset url is not null', function () {
config(['app.asset_url' => 'https://an-s3-bucket']);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
expect(asset('foo'))->toBe("https://an-s3-bucket/tenant{$tenant->id}/foo");
});
test('global asset helper returns the same url regardless of tenancy initialization', function () {
$original = global_asset('foobar');
expect(global_asset('foobar'))->toBe(asset('foobar'));
$tenant = Tenant::create();
tenancy()->initialize($tenant);
expect(global_asset('foobar'))->toBe($original);
});
test('asset helper tenancy can be disabled', function () {
$original = asset('foo');
config([
'app.asset_url' => null,
'tenancy.filesystem.asset_helper_tenancy' => false,
]);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
expect(asset('foo'))->toBe($original);
});
function getEnvironmentSetUp($app)
{
public function getEnvironmentSetUp($app)
{
parent::getEnvironmentSetUp($app);
$app->booted(function () {
if (file_exists(base_path('routes/tenant.php'))) {
Route::middleware(['web'])
->namespace($this->app['config']['tenancy.tenant_route_namespace'] ?? 'App\Http\Controllers')
->group(base_path('routes/tenant.php'));
}
});
}
public function setUp(): void
{
parent::setUp();
config(['tenancy.bootstrappers' => [
FilesystemTenancyBootstrapper::class,
]]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
}
public function tearDown(): void
{
parent::tearDown();
// Cleanup
TenantAssetsController::$tenancyMiddleware = InitializeTenancyByDomain::class;
}
/** @test */
public function asset_can_be_accessed_using_the_url_returned_by_the_tenant_asset_helper()
{
TenantAssetsController::$tenancyMiddleware = InitializeTenancyByRequestData::class;
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$filename = 'testfile' . $this->randomString(10);
Storage::disk('public')->put($filename, 'bar');
$path = storage_path("app/public/$filename");
// response()->file() returns BinaryFileResponse whose content is
// inaccessible via getContent, so ->assertSee() can't be used
$this->assertFileExists($path);
$response = $this->get(tenant_asset($filename), [
'X-Tenant' => $tenant->id,
]);
$response->assertSuccessful();
$f = fopen($path, 'r');
$content = fread($f, filesize($path));
fclose($f);
$this->assertSame('bar', $content);
}
/** @test */
public function asset_helper_returns_a_link_to_TenantAssetController_when_asset_url_is_null()
{
config(['app.asset_url' => null]);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$this->assertSame(route('stancl.tenancy.asset', ['path' => 'foo']), asset('foo'));
}
/** @test */
public function asset_helper_returns_a_link_to_an_external_url_when_asset_url_is_not_null()
{
config(['app.asset_url' => 'https://an-s3-bucket']);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$this->assertSame("https://an-s3-bucket/tenant{$tenant->id}/foo", asset('foo'));
}
/** @test */
public function global_asset_helper_returns_the_same_url_regardless_of_tenancy_initialization()
{
$original = global_asset('foobar');
$this->assertSame(asset('foobar'), global_asset('foobar'));
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$this->assertSame($original, global_asset('foobar'));
}
/** @test */
public function asset_helper_tenancy_can_be_disabled()
{
$original = asset('foo');
config([
'app.asset_url' => null,
'tenancy.filesystem.asset_helper_tenancy' => false,
]);
$tenant = Tenant::create();
tenancy()->initialize($tenant);
$this->assertSame($original, asset('foo'));
}
$app->booted(function () {
if (file_exists(base_path('routes/tenant.php'))) {
Route::middleware(['web'])
->namespace(pest()->app['config']['tenancy.tenant_route_namespace'] ?? 'App\Http\Controllers')
->group(base_path('routes/tenant.php'));
}
});
}

37
tests/TenantAwareCommandTest.php
View file

@ -2,32 +2,25 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\DB;
use Stancl\Tenancy\Tests\Etc\Tenant;
class TenantAwareCommandTest extends TestCase
{
/** @test */
public function commands_run_globally_are_tenant_aware_and_return_valid_exit_code()
{
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
Artisan::call('tenants:migrate', [
'--tenants' => [$tenant1['id'], $tenant2['id']],
]);
test('commands run globally are tenant aware and return valid exit code', function () {
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
Artisan::call('tenants:migrate', [
'--tenants' => [$tenant1['id'], $tenant2['id']],
]);
$this->artisan('user:add')
->assertExitCode(0);
pest()->artisan('user:add')
->assertExitCode(0);
tenancy()->initialize($tenant1);
$this->assertNotEmpty(DB::table('users')->get());
tenancy()->end();
tenancy()->initialize($tenant1);
pest()->assertNotEmpty(DB::table('users')->get());
tenancy()->end();
tenancy()->initialize($tenant2);
$this->assertNotEmpty(DB::table('users')->get());
tenancy()->end();
}
}
tenancy()->initialize($tenant2);
pest()->assertNotEmpty(DB::table('users')->get());
tenancy()->end();
});

426
tests/TenantDatabaseManagerTest.php
View file

@ -2,19 +2,21 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Str;
use PDO;
use Stancl\JobPipeline\JobPipeline;
use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
use Stancl\Tenancy\Database\DatabaseManager;
use Stancl\Tenancy\Events\TenancyEnded;
use Stancl\Tenancy\Events\TenancyInitialized;
use Stancl\Tenancy\Events\TenantCreated;
use Stancl\Tenancy\Exceptions\TenantDatabaseAlreadyExistsException;
use Stancl\Tenancy\Jobs\CreateDatabase;
use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\TenantDatabaseManagers\MicrosoftSQLDatabaseManager;
use Stancl\Tenancy\TenantDatabaseManagers\MySQLDatabaseManager;
use Stancl\Tenancy\TenantDatabaseManagers\PermissionControlledMySQLDatabaseManager;
use Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLDatabaseManager;
@ -22,200 +24,228 @@ use Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLSchemaManager;
use Stancl\Tenancy\TenantDatabaseManagers\SQLiteDatabaseManager;
use Stancl\Tenancy\Tests\Etc\Tenant;
class TenantDatabaseManagerTest extends TestCase
test('databases can be created and deleted', function ($driver, $databaseManager) {
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
config()->set([
"tenancy.database.managers.$driver" => $databaseManager,
]);
$name = 'db' . pest()->randomString();
$manager = app($databaseManager);
$manager->setConnection($driver);
expect($manager->databaseExists($name))->toBeFalse();
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => $driver,
]);
expect($manager->databaseExists($name))->toBeTrue();
$manager->deleteDatabase($tenant);
expect($manager->databaseExists($name))->toBeFalse();
})->with('database_manager_provider');
test('dbs can be created when another driver is used for the central db', function () {
expect(config('database.default'))->toBe('central');
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$database = 'db' . pest()->randomString();
$mysqlmanager = app(MySQLDatabaseManager::class);
$mysqlmanager->setConnection('mysql');
expect($mysqlmanager->databaseExists($database))->toBeFalse();
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'mysql',
]);
expect($mysqlmanager->databaseExists($database))->toBeTrue();
$postgresManager = app(PostgreSQLDatabaseManager::class);
$postgresManager->setConnection('pgsql');
$database = 'db' . pest()->randomString();
expect($postgresManager->databaseExists($database))->toBeFalse();
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'pgsql',
]);
expect($postgresManager->databaseExists($database))->toBeTrue();
});
test('the tenant connection is fully removed', function () {
config([
'tenancy.boostrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
$tenant = Tenant::create();
expect(array_keys(app('db')->getConnections()))->toBe(['central']);
pest()->assertArrayNotHasKey('tenant', config('database.connections'));
tenancy()->initialize($tenant);
createUsersTable();
expect(array_keys(app('db')->getConnections()))->toBe(['central', 'tenant']);
pest()->assertArrayHasKey('tenant', config('database.connections'));
tenancy()->end();
expect(array_keys(app('db')->getConnections()))->toBe(['central']);
expect(config('database.connections.tenant'))->toBeNull();
});
test('db name is prefixed with db path when sqlite is used', function () {
if (file_exists(database_path('foodb'))) {
unlink(database_path('foodb')); // cleanup
}
config([
'database.connections.fooconn.driver' => 'sqlite',
]);
$tenant = Tenant::create([
'tenancy_db_name' => 'foodb',
'tenancy_db_connection' => 'fooconn',
]);
app(DatabaseManager::class)->createTenantConnection($tenant);
expect(database_path('foodb'))->toBe(config('database.connections.tenant.database'));
});
test('schema manager uses schema to separate tenant dbs', function () {
config([
'tenancy.database.managers.pgsql' => \Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLSchemaManager::class,
'tenancy.boostrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
$originalDatabaseName = config(['database.connections.pgsql.database']);
$tenant = Tenant::create([
'tenancy_db_connection' => 'pgsql',
]);
tenancy()->initialize($tenant);
$schemaConfig = version_compare(app()->version(), '9.0', '>=') ?
config('database.connections.' . config('database.default') . '.search_path') :
config('database.connections.' . config('database.default') . '.schema');
expect($schemaConfig)->toBe($tenant->database()->getName());
expect(config(['database.connections.pgsql.database']))->toBe($originalDatabaseName);
});
test('a tenants database cannot be created when the database already exists', function () {
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
]);
$manager = $tenant->database()->manager();
expect($manager->databaseExists($tenant->database()->getName()))->toBeTrue();
pest()->expectException(TenantDatabaseAlreadyExistsException::class);
$tenant2 = Tenant::create([
'tenancy_db_name' => $name,
]);
});
test('tenant database can be created on a foreign server', function () {
config([
'tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class,
'database.connections.mysql2' => [
'driver' => 'mysql',
'host' => 'mysql2', // important line
'port' => 3306,
'database' => 'main',
'username' => 'root',
'password' => 'password',
'unix_socket' => env('DB_SOCKET', ''),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'prefix' => '',
'prefix_indexes' => true,
'strict' => true,
'engine' => null,
'options' => extension_loaded('pdo_mysql') ? array_filter([
PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
]) : [],
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => 'mysql2',
]);
/** @var PermissionControlledMySQLDatabaseManager $manager */
$manager = $tenant->database()->manager();
$manager->setConnection('mysql');
expect($manager->databaseExists($name))->toBeFalse();
$manager->setConnection('mysql2');
expect($manager->databaseExists($name))->toBeTrue();
});
test('path used by sqlite manager can be customized', function () {
pest()->markTestIncomplete();
});
// Datasets
dataset('database_manager_provider', [
['mysql', MySQLDatabaseManager::class],
['mysql', PermissionControlledMySQLDatabaseManager::class],
['sqlite', SQLiteDatabaseManager::class],
['pgsql', PostgreSQLDatabaseManager::class],
['pgsql', PostgreSQLSchemaManager::class],
['sqlsrv', MicrosoftSQLDatabaseManager::class]
]);
function createUsersTable()
{
/**
* @test
* @dataProvider database_manager_provider
*/
public function databases_can_be_created_and_deleted($driver, $databaseManager)
{
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
config()->set([
"tenancy.database.managers.$driver" => $databaseManager,
]);
$name = 'db' . $this->randomString();
$manager = app($databaseManager);
$manager->setConnection($driver);
$this->assertFalse($manager->databaseExists($name));
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => $driver,
]);
$this->assertTrue($manager->databaseExists($name));
$manager->deleteDatabase($tenant);
$this->assertFalse($manager->databaseExists($name));
}
/** @test */
public function dbs_can_be_created_when_another_driver_is_used_for_the_central_db()
{
$this->assertSame('central', config('database.default'));
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$database = 'db' . $this->randomString();
$mysqlmanager = app(MySQLDatabaseManager::class);
$mysqlmanager->setConnection('mysql');
$this->assertFalse($mysqlmanager->databaseExists($database));
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'mysql',
]);
$this->assertTrue($mysqlmanager->databaseExists($database));
$postgresManager = app(PostgreSQLDatabaseManager::class);
$postgresManager->setConnection('pgsql');
$database = 'db' . $this->randomString();
$this->assertFalse($postgresManager->databaseExists($database));
Tenant::create([
'tenancy_db_name' => $database,
'tenancy_db_connection' => 'pgsql',
]);
$this->assertTrue($postgresManager->databaseExists($database));
}
public function database_manager_provider()
{
return [
['mysql', MySQLDatabaseManager::class],
['mysql', PermissionControlledMySQLDatabaseManager::class],
['sqlite', SQLiteDatabaseManager::class],
['pgsql', PostgreSQLDatabaseManager::class],
['pgsql', PostgreSQLSchemaManager::class],
];
}
/** @test */
public function db_name_is_prefixed_with_db_path_when_sqlite_is_used()
{
if (file_exists(database_path('foodb'))) {
unlink(database_path('foodb')); // cleanup
}
config([
'database.connections.fooconn.driver' => 'sqlite',
]);
$tenant = Tenant::create([
'tenancy_db_name' => 'foodb',
'tenancy_db_connection' => 'fooconn',
]);
app(DatabaseManager::class)->createTenantConnection($tenant);
$this->assertSame(config('database.connections.tenant.database'), database_path('foodb'));
}
/** @test */
public function schema_manager_uses_schema_to_separate_tenant_dbs()
{
config([
'tenancy.database.managers.pgsql' => \Stancl\Tenancy\TenantDatabaseManagers\PostgreSQLSchemaManager::class,
'tenancy.boostrappers' => [
DatabaseTenancyBootstrapper::class,
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
$originalDatabaseName = config(['database.connections.pgsql.database']);
$tenant = Tenant::create([
'tenancy_db_connection' => 'pgsql',
]);
tenancy()->initialize($tenant);
$this->assertSame($tenant->database()->getName(), config('database.connections.' . config('database.default') . '.schema'));
$this->assertSame($originalDatabaseName, config(['database.connections.pgsql.database']));
}
/** @test */
public function a_tenants_database_cannot_be_created_when_the_database_already_exists()
{
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
]);
$manager = $tenant->database()->manager();
$this->assertTrue($manager->databaseExists($tenant->database()->getName()));
$this->expectException(TenantDatabaseAlreadyExistsException::class);
$tenant2 = Tenant::create([
'tenancy_db_name' => $name,
]);
}
/** @test */
public function tenant_database_can_be_created_on_a_foreign_server()
{
config([
'tenancy.database.managers.mysql' => PermissionControlledMySQLDatabaseManager::class,
'database.connections.mysql2' => [
'driver' => 'mysql',
'host' => 'mysql2', // important line
'port' => 3306,
'database' => 'main',
'username' => 'root',
'password' => 'password',
'unix_socket' => env('DB_SOCKET', ''),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'prefix' => '',
'prefix_indexes' => true,
'strict' => true,
'engine' => null,
'options' => extension_loaded('pdo_mysql') ? array_filter([
PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
]) : [],
],
]);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener());
$name = 'foo' . Str::random(8);
$tenant = Tenant::create([
'tenancy_db_name' => $name,
'tenancy_db_connection' => 'mysql2',
]);
/** @var PermissionControlledMySQLDatabaseManager $manager */
$manager = $tenant->database()->manager();
$manager->setConnection('mysql');
$this->assertFalse($manager->databaseExists($name));
$manager->setConnection('mysql2');
$this->assertTrue($manager->databaseExists($name));
}
/** @test */
public function path_used_by_sqlite_manager_can_be_customized()
{
}
Schema::create('users', function (Blueprint $table) {
$table->increments('id');
$table->string('name');
$table->string('email')->unique();
$table->string('password');
$table->rememberToken();
$table->timestamps();
});
}

222
tests/TenantModelTest.php
View file

@ -2,8 +2,6 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Event;
@ -21,148 +19,127 @@ use Stancl\Tenancy\Listeners\BootstrapTenancy;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Stancl\Tenancy\UUIDGenerator;
class TenantModelTest extends TestCase
{
/** @test */
public function created_event_is_dispatched()
{
Event::fake([TenantCreated::class]);
test('created event is dispatched', function () {
Event::fake([TenantCreated::class]);
Event::assertNotDispatched(TenantCreated::class);
Event::assertNotDispatched(TenantCreated::class);
Tenant::create();
Tenant::create();
Event::assertDispatched(TenantCreated::class);
}
Event::assertDispatched(TenantCreated::class);
});
/** @test */
public function current_tenant_can_be_resolved_from_service_container_using_typehint()
{
$tenant = Tenant::create();
test('current tenant can be resolved from service container using typehint', function () {
$tenant = Tenant::create();
tenancy()->initialize($tenant);
tenancy()->initialize($tenant);
$this->assertSame($tenant->id, app(Contracts\Tenant::class)->id);
expect(app(Contracts\Tenant::class)->id)->toBe($tenant->id);
tenancy()->end();
tenancy()->end();
$this->assertSame(null, app(Contracts\Tenant::class));
}
expect(app(Contracts\Tenant::class))->toBe(null);
});
/** @test */
public function id_is_generated_when_no_id_is_supplied()
{
config(['tenancy.id_generator' => UUIDGenerator::class]);
test('id is generated when no id is supplied', function () {
config(['tenancy.id_generator' => UUIDGenerator::class]);
$this->mock(UUIDGenerator::class, function ($mock) {
return $mock->shouldReceive('generate')->once();
});
$this->mock(UUIDGenerator::class, function ($mock) {
return $mock->shouldReceive('generate')->once();
});
$tenant = Tenant::create();
$tenant = Tenant::create();
$this->assertNotNull($tenant->id);
}
pest()->assertNotNull($tenant->id);
});
/** @test */
public function autoincrement_ids_are_supported()
{
Schema::drop('domains');
Schema::table('tenants', function (Blueprint $table) {
$table->bigIncrements('id')->change();
});
test('autoincrement ids are supported', function () {
Schema::drop('domains');
Schema::table('tenants', function (Blueprint $table) {
$table->bigIncrements('id')->change();
});
unset(app()[UniqueIdentifierGenerator::class]);
unset(app()[UniqueIdentifierGenerator::class]);
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
$tenant1 = Tenant::create();
$tenant2 = Tenant::create();
$this->assertSame(1, $tenant1->id);
$this->assertSame(2, $tenant2->id);
}
expect($tenant1->id)->toBe(1);
expect($tenant2->id)->toBe(2);
});
/** @test */
public function custom_tenant_model_can_be_used()
{
$tenant = MyTenant::create();
test('custom tenant model can be used', function () {
$tenant = MyTenant::create();
tenancy()->initialize($tenant);
tenancy()->initialize($tenant);
$this->assertTrue(tenant() instanceof MyTenant);
}
expect(tenant() instanceof MyTenant)->toBeTrue();
});
/** @test */
public function custom_tenant_model_that_doesnt_extend_vendor_Tenant_model_can_be_used()
{
$tenant = AnotherTenant::create([
'id' => 'acme',
test('custom tenant model that doesnt extend vendor tenant model can be used', function () {
$tenant = AnotherTenant::create([
'id' => 'acme',
]);
tenancy()->initialize($tenant);
expect(tenant() instanceof AnotherTenant)->toBeTrue();
});
test('tenant can be created even when we are in another tenants context', function () {
config(['tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
]]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function ($event) {
return $event->tenant;
})->toListener());
$tenant1 = Tenant::create([
'id' => 'foo',
'tenancy_db_name' => 'db' . Str::random(16),
]);
tenancy()->initialize($tenant1);
$tenant2 = Tenant::create([
'id' => 'bar',
'tenancy_db_name' => 'db' . Str::random(16),
]);
tenancy()->end();
expect(Tenant::count())->toBe(2);
});
test('the model uses tenant collection', function () {
Tenant::create();
Tenant::create();
expect(Tenant::count())->toBe(2);
expect(Tenant::all() instanceof TenantCollection)->toBeTrue();
});
test('a command can be run on a collection of tenants', function () {
Tenant::create([
'id' => 't1',
'foo' => 'bar',
]);
Tenant::create([
'id' => 't2',
'foo' => 'bar',
]);
Tenant::all()->runForEach(function ($tenant) {
$tenant->update([
'foo' => 'xyz',
]);
});
tenancy()->initialize($tenant);
$this->assertTrue(tenant() instanceof AnotherTenant);
}
/** @test */
public function tenant_can_be_created_even_when_we_are_in_another_tenants_context()
{
config(['tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
]]);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenantCreated::class, JobPipeline::make([CreateDatabase::class])->send(function ($event) {
return $event->tenant;
})->toListener());
$tenant1 = Tenant::create([
'id' => 'foo',
'tenancy_db_name' => 'db' . Str::random(16),
]);
tenancy()->initialize($tenant1);
$tenant2 = Tenant::create([
'id' => 'bar',
'tenancy_db_name' => 'db' . Str::random(16),
]);
tenancy()->end();
$this->assertSame(2, Tenant::count());
}
/** @test */
public function the_model_uses_TenantCollection()
{
Tenant::create();
Tenant::create();
$this->assertSame(2, Tenant::count());
$this->assertTrue(Tenant::all() instanceof TenantCollection);
}
/** @test */
public function a_command_can_be_run_on_a_collection_of_tenants()
{
Tenant::create([
'id' => 't1',
'foo' => 'bar',
]);
Tenant::create([
'id' => 't2',
'foo' => 'bar',
]);
Tenant::all()->runForEach(function ($tenant) {
$tenant->update([
'foo' => 'xyz',
]);
});
$this->assertSame('xyz', Tenant::find('t1')->foo);
$this->assertSame('xyz', Tenant::find('t2')->foo);
}
}
expect(Tenant::find('t1')->foo)->toBe('xyz');
expect(Tenant::find('t2')->foo)->toBe('xyz');
});
class MyTenant extends Tenant
{
@ -172,6 +149,7 @@ class MyTenant extends Tenant
class AnotherTenant extends Model implements Contracts\Tenant
{
protected $guarded = [];
protected $table = 'tenants';
public function getTenantKeyName(): string

463
tests/TenantUserImpersonationTest.php
View file

@ -2,13 +2,9 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Carbon\Carbon;
use Carbon\CarbonInterval;
use Closure;
use Illuminate\Auth\SessionGuard;
use Illuminate\Foundation\Auth\User as Authenticable;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Route;
@ -26,259 +22,246 @@ use Stancl\Tenancy\Listeners\RevertToCentralContext;
use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
use Stancl\Tenancy\Middleware\InitializeTenancyByPath;
use Stancl\Tenancy\Tests\Etc\Tenant;
use Illuminate\Foundation\Auth\User as Authenticable;
class TenantUserImpersonationTest extends TestCase
beforeEach(function () {
pest()->artisan('migrate', [
'--path' => __DIR__ . '/../assets/impersonation-migrations',
'--realpath' => true,
])->assertExitCode(0);
config([
'tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
],
'tenancy.features' => [
UserImpersonation::class,
],
]);
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
config(['auth.providers.users.model' => ImpersonationUser::class]);
});
test('tenant user can be impersonated on a tenant domain', function () {
Route::middleware(InitializeTenancyByDomain::class)->group(getRoutes());
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We try to visit the dashboard directly, before impersonating the user.
pest()->get('http://foo.localhost/dashboard')
->assertRedirect('http://foo.localhost/login');
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard');
pest()->get('http://foo.localhost/impersonate/' . $token->token)
->assertRedirect('http://foo.localhost/dashboard');
// Now we try to visit the dashboard directly, after impersonating the user.
pest()->get('http://foo.localhost/dashboard')
->assertSuccessful()
->assertSee('You are logged in as Joe');
});
test('tenant user can be impersonated on a tenant path', function () {
makeLoginRoute();
Route::middleware(InitializeTenancyByPath::class)->prefix('/{tenant}')->group(getRoutes(false));
$tenant = Tenant::create([
'id' => 'acme',
'tenancy_db_name' => 'db' . Str::random(16),
]);
migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We try to visit the dashboard directly, before impersonating the user.
pest()->get('/acme/dashboard')
->assertRedirect('/login');
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/acme/dashboard');
pest()->get('/acme/impersonate/' . $token->token)
->assertRedirect('/acme/dashboard');
// Now we try to visit the dashboard directly, after impersonating the user.
pest()->get('/acme/dashboard')
->assertSuccessful()
->assertSee('You are logged in as Joe');
});
test('tokens have a limited ttl', function () {
Route::middleware(InitializeTenancyByDomain::class)->group(getRoutes());
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard');
$token->update([
'created_at' => Carbon::now()->subtract(CarbonInterval::make('100s')),
]);
pest()->followingRedirects()
->get('http://foo.localhost/impersonate/' . $token->token)
->assertStatus(403);
});
test('tokens are deleted after use', function () {
Route::middleware(InitializeTenancyByDomain::class)->group(getRoutes());
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard');
pest()->assertNotNull(ImpersonationToken::find($token->token));
pest()->followingRedirects()
->get('http://foo.localhost/impersonate/' . $token->token)
->assertSuccessful()
->assertSee('You are logged in as Joe');
expect(ImpersonationToken::find($token->token))->toBeNull();
});
test('impersonation works with multiple models and guards', function () {
config([
'auth.guards.another' => [
'driver' => 'session',
'provider' => 'another_users',
],
'auth.providers.another_users' => [
'driver' => 'eloquent',
'model' => AnotherImpersonationUser::class,
],
]);
Auth::extend('another', function ($app, $name, array $config) {
return new SessionGuard($name, Auth::createUserProvider($config['provider']), session());
});
Route::middleware(InitializeTenancyByDomain::class)->group(getRoutes(true, 'another'));
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
migrateTenants();
$user = $tenant->run(function () {
return AnotherImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We try to visit the dashboard directly, before impersonating the user.
pest()->get('http://foo.localhost/dashboard')
->assertRedirect('http://foo.localhost/login');
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard', 'another');
pest()->get('http://foo.localhost/impersonate/' . $token->token)
->assertRedirect('http://foo.localhost/dashboard');
// Now we try to visit the dashboard directly, after impersonating the user.
pest()->get('http://foo.localhost/dashboard')
->assertSuccessful()
->assertSee('You are logged in as Joe');
Tenant::first()->run(function () {
expect(auth()->guard('another')->user()->name)->toBe('Joe');
expect(auth()->guard('web')->user())->toBe(null);
});
});
function migrateTenants()
{
protected function migrateTenants()
{
$this->artisan('tenants:migrate')->assertExitCode(0);
}
pest()->artisan('tenants:migrate')->assertExitCode(0);
}
public function setUp(): void
{
parent::setUp();
function makeLoginRoute()
{
Route::get('/login', function () {
return 'Please log in';
})->name('login');
}
$this->artisan('migrate', [
'--path' => __DIR__ . '/../assets/impersonation-migrations',
'--realpath' => true,
])->assertExitCode(0);
function getRoutes($loginRoute = true, $authGuard = 'web'): Closure
{
return function () use ($loginRoute, $authGuard) {
if ($loginRoute) {
makeLoginRoute();
}
config([
'tenancy.bootstrappers' => [
DatabaseTenancyBootstrapper::class,
],
'tenancy.features' => [
UserImpersonation::class,
],
]);
Route::get('/dashboard', function () use ($authGuard) {
return 'You are logged in as ' . auth()->guard($authGuard)->user()->name;
})->middleware('auth:' . $authGuard);
Event::listen(
TenantCreated::class,
JobPipeline::make([CreateDatabase::class])->send(function (TenantCreated $event) {
return $event->tenant;
})->toListener()
);
Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
Event::listen(TenancyEnded::class, RevertToCentralContext::class);
config(['auth.providers.users.model' => ImpersonationUser::class]);
}
public function makeLoginRoute()
{
Route::get('/login', function () {
return 'Please log in';
})->name('login');
}
public function getRoutes($loginRoute = true, $authGuard = 'web'): Closure
{
return function () use ($loginRoute, $authGuard) {
if ($loginRoute) {
$this->makeLoginRoute();
}
Route::get('/dashboard', function () use ($authGuard) {
return 'You are logged in as ' . auth()->guard($authGuard)->user()->name;
})->middleware('auth:' . $authGuard);
Route::get('/impersonate/{token}', function ($token) {
return UserImpersonation::makeResponse($token);
});
};
}
/** @test */
public function tenant_user_can_be_impersonated_on_a_tenant_domain()
{
Route::middleware(InitializeTenancyByDomain::class)->group($this->getRoutes());
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$this->migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
Route::get('/impersonate/{token}', function ($token) {
return UserImpersonation::makeResponse($token);
});
// We try to visit the dashboard directly, before impersonating the user.
$this->get('http://foo.localhost/dashboard')
->assertRedirect('http://foo.localhost/login');
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard');
$this->get('http://foo.localhost/impersonate/' . $token->token)
->assertRedirect('http://foo.localhost/dashboard');
// Now we try to visit the dashboard directly, after impersonating the user.
$this->get('http://foo.localhost/dashboard')
->assertSuccessful()
->assertSee('You are logged in as Joe');
}
/** @test */
public function tenant_user_can_be_impersonated_on_a_tenant_path()
{
$this->makeLoginRoute();
Route::middleware(InitializeTenancyByPath::class)->prefix('/{tenant}')->group($this->getRoutes(false));
$tenant = Tenant::create([
'id' => 'acme',
'tenancy_db_name' => 'db' . Str::random(16),
]);
$this->migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We try to visit the dashboard directly, before impersonating the user.
$this->get('/acme/dashboard')
->assertRedirect('/login');
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/acme/dashboard');
$this->get('/acme/impersonate/' . $token->token)
->assertRedirect('/acme/dashboard');
// Now we try to visit the dashboard directly, after impersonating the user.
$this->get('/acme/dashboard')
->assertSuccessful()
->assertSee('You are logged in as Joe');
}
/** @test */
public function tokens_have_a_limited_ttl()
{
Route::middleware(InitializeTenancyByDomain::class)->group($this->getRoutes());
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$this->migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard');
$token->update([
'created_at' => Carbon::now()->subtract(CarbonInterval::make('100s')),
]);
$this->followingRedirects()
->get('http://foo.localhost/impersonate/' . $token->token)
->assertStatus(403);
}
/** @test */
public function tokens_are_deleted_after_use()
{
Route::middleware(InitializeTenancyByDomain::class)->group($this->getRoutes());
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$this->migrateTenants();
$user = $tenant->run(function () {
return ImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard');
$this->assertNotNull(ImpersonationToken::find($token->token));
$this->followingRedirects()
->get('http://foo.localhost/impersonate/' . $token->token)
->assertSuccessful()
->assertSee('You are logged in as Joe');
$this->assertNull(ImpersonationToken::find($token->token));
}
/** @test */
public function impersonation_works_with_multiple_models_and_guards()
{
config([
'auth.guards.another' => [
'driver' => 'session',
'provider' => 'another_users',
],
'auth.providers.another_users' => [
'driver' => 'eloquent',
'model' => AnotherImpersonationUser::class,
],
]);
Auth::extend('another', function ($app, $name, array $config) {
return new SessionGuard($name, Auth::createUserProvider($config['provider']), session());
});
Route::middleware(InitializeTenancyByDomain::class)->group($this->getRoutes(true, 'another'));
$tenant = Tenant::create();
$tenant->domains()->create([
'domain' => 'foo.localhost',
]);
$this->migrateTenants();
$user = $tenant->run(function () {
return AnotherImpersonationUser::create([
'name' => 'Joe',
'email' => 'joe@local',
'password' => bcrypt('secret'),
]);
});
// We try to visit the dashboard directly, before impersonating the user.
$this->get('http://foo.localhost/dashboard')
->assertRedirect('http://foo.localhost/login');
// We impersonate the user
$token = tenancy()->impersonate($tenant, $user->id, '/dashboard', 'another');
$this->get('http://foo.localhost/impersonate/' . $token->token)
->assertRedirect('http://foo.localhost/dashboard');
// Now we try to visit the dashboard directly, after impersonating the user.
$this->get('http://foo.localhost/dashboard')
->assertSuccessful()
->assertSee('You are logged in as Joe');
Tenant::first()->run(function () {
$this->assertSame('Joe', auth()->guard('another')->user()->name);
$this->assertSame(null, auth()->guard('web')->user());
});
}
};
}
class ImpersonationUser extends Authenticable
{
protected $guarded = [];
protected $table = 'users';
}
class AnotherImpersonationUser extends Authenticable
{
protected $guarded = [];
protected $table = 'users';
}

13
tests/TestCase.php
View file

@ -23,7 +23,7 @@ abstract class TestCase extends \Orchestra\Testbench\TestCase
Redis::connection('cache')->flushdb();
file_put_contents(database_path('central.sqlite'), '');
$this->artisan('migrate:fresh', [
pest()->artisan('migrate:fresh', [
'--force' => true,
'--path' => __DIR__ . '/../assets/migrations',
'--realpath' => true,
@ -48,7 +48,11 @@ abstract class TestCase extends \Orchestra\Testbench\TestCase
protected function getEnvironmentSetUp($app)
{
if (file_exists(__DIR__ . '/../.env')) {
\Dotenv\Dotenv::create(__DIR__ . '/..')->load();
if (method_exists(\Dotenv\Dotenv::class, 'createImmutable')) {
\Dotenv\Dotenv::createImmutable(__DIR__ . '/..')->load();
} else {
\Dotenv\Dotenv::create(__DIR__ . '/..')->load();
}
}
$app['config']->set([
@ -77,12 +81,17 @@ abstract class TestCase extends \Orchestra\Testbench\TestCase
],
'database.connections.sqlite.database' => ':memory:',
'database.connections.mysql.host' => env('TENANCY_TEST_MYSQL_HOST', '127.0.0.1'),
'database.connections.sqlsrv.username' => env('TENANCY_TEST_SQLSRV_USERNAME', 'sa'),
'database.connections.sqlsrv.password' => env('TENANCY_TEST_SQLSRV_PASSWORD', 'P@ssword'),
'database.connections.sqlsrv.host' => env('TENANCY_TEST_SQLSRV_HOST', '127.0.0.1'),
'database.connections.sqlsrv.database' => null,
'database.connections.pgsql.host' => env('TENANCY_TEST_PGSQL_HOST', '127.0.0.1'),
'tenancy.filesystem.disks' => [
'local',
'public',
's3',
],
'filesystems.disks.s3.bucket' => 'foo',
'tenancy.redis.tenancy' => env('TENANCY_TEST_REDIS_TENANCY', true),
'database.redis.client' => env('TENANCY_TEST_REDIS_CLIENT', 'phpredis'),
'tenancy.redis.prefixed_connections' => ['default'],

105
tests/UniversalRouteTest.php
View file

@ -2,65 +2,76 @@
declare(strict_types=1);
namespace Stancl\Tenancy\Tests;
use Illuminate\Support\Facades\Route;
use Stancl\Tenancy\Features\UniversalRoutes;
use Stancl\Tenancy\Middleware\InitializeTenancyByDomain;
use Stancl\Tenancy\Tests\Etc\Tenant;
class UniversalRouteTest extends TestCase
{
public function tearDown(): void
{
InitializeTenancyByDomain::$onFail = null;
afterEach(function () {
InitializeTenancyByDomain::$onFail = null;
});
parent::tearDown();
}
test('a route can work in both central and tenant context', function () {
Route::middlewareGroup('universal', []);
config(['tenancy.features' => [UniversalRoutes::class]]);
/** @test */
public function a_route_can_work_in_both_central_and_tenant_context()
{
Route::middlewareGroup('universal', []);
config(['tenancy.features' => [UniversalRoutes::class]]);
Route::get('/foo', function () {
return tenancy()->initialized
? 'Tenancy is initialized.'
: 'Tenancy is not initialized.';
})->middleware(['universal', InitializeTenancyByDomain::class]);
Route::get('/foo', function () {
return tenancy()->initialized
? 'Tenancy is initialized.'
: 'Tenancy is not initialized.';
})->middleware(['universal', InitializeTenancyByDomain::class]);
pest()->get('http://localhost/foo')
->assertSuccessful()
->assertSee('Tenancy is not initialized.');
$this->get('http://localhost/foo')
->assertSuccessful()
->assertSee('Tenancy is not initialized.');
$tenant = Tenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'acme.localhost',
]);
$tenant = Tenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'acme.localhost',
]);
pest()->get('http://acme.localhost/foo')
->assertSuccessful()
->assertSee('Tenancy is initialized.');
});
$this->get('http://acme.localhost/foo')
->assertSuccessful()
->assertSee('Tenancy is initialized.');
}
test('making one route universal doesnt make all routes universal', function () {
Route::get('/bar', function () {
return tenant('id');
})->middleware(InitializeTenancyByDomain::class);
/** @test */
public function making_one_route_universal_doesnt_make_all_routes_universal()
{
Route::get('/bar', function () {
return tenant('id');
})->middleware(InitializeTenancyByDomain::class);
Route::middlewareGroup('universal', []);
config(['tenancy.features' => [UniversalRoutes::class]]);
$this->a_route_can_work_in_both_central_and_tenant_context();
tenancy()->end();
Route::get('/foo', function () {
return tenancy()->initialized
? 'Tenancy is initialized.'
: 'Tenancy is not initialized.';
})->middleware(['universal', InitializeTenancyByDomain::class]);
$this->get('http://localhost/bar')
->assertStatus(500);
pest()->get('http://localhost/foo')
->assertSuccessful()
->assertSee('Tenancy is not initialized.');
$this->get('http://acme.localhost/bar')
->assertSuccessful()
->assertSee('acme');
}
}
$tenant = Tenant::create([
'id' => 'acme',
]);
$tenant->domains()->create([
'domain' => 'acme.localhost',
]);
pest()->get('http://acme.localhost/foo')
->assertSuccessful()
->assertSee('Tenancy is initialized.');
tenancy()->end();
pest()->get('http://localhost/bar')
->assertStatus(500);
pest()->get('http://acme.localhost/bar')
->assertSuccessful()
->assertSee('acme');
});