refactor: replace custom CRM with Monica fork
Some checks failed
Build & Push Monica Image to Gitea Registry / build-and-push (push) Failing after 9s

This commit is contained in:
Kroonk
2026-05-22 16:19:55 +02:00
parent 38cc4c09ca
commit a213a1dba0
2215 changed files with 242567 additions and 6015 deletions

View File

@@ -0,0 +1,249 @@
<?php
namespace Tests\Unit\Services\Account\Activity;
use Carbon\Carbon;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Contact\Contact;
use App\Models\Account\Activity;
use App\Models\Account\ActivityType;
use App\Models\Account\ActivityStatistic;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use App\Services\Account\Activity\ActivityStatisticService;
class ActivityStatisticServiceTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_gets_a_list_of_activities_since_a_given_number_of_months()
{
$service = new ActivityStatisticService;
$contact = factory(Contact::class)->create();
for ($i = 0; $i <= 2; $i++) {
$activity = factory(Activity::class)->create([
'happened_at' => now()->subMonth(),
'account_id' => $contact->account_id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
}
$this->assertCount(
3,
$service->activitiesWithContactInTimeRange($contact, now()->subMonths(2), now())
);
$this->assertInstanceOf(
Activity::class,
$service->activitiesWithContactInTimeRange($contact, now()->subMonths(2), now())[1]
);
}
/** @test */
public function it_gets_an_empty_list_of_activities()
{
$service = new ActivityStatisticService;
$contact = factory(Contact::class)->create();
for ($i = 0; $i <= 2; $i++) {
$activity = factory(Activity::class)->create([
'happened_at' => now()->subYears(2),
'account_id' => $contact->account_id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
}
$this->assertCount(
0,
$service->activitiesWithContactInTimeRange($contact, now()->subMonths(2), now())
);
}
/** @test */
public function it_gets_a_list_of_unique_activity_types()
{
$service = new ActivityStatisticService;
$account = factory(Account::class)->create();
$contact = factory(Contact::class)->create([
'account_id' => $account->id,
]);
// creation of 3 activities with a given activity type
$activityType = factory(ActivityType::class)->create([
'account_id' => $account->id,
]);
for ($i = 0; $i <= 2; $i++) {
$activity = factory(Activity::class)->create([
'happened_at' => now(),
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
}
// creation of 1 activity with a given activity type
$activityType = factory(ActivityType::class)->create([
'account_id' => $account->id,
]);
$activity = factory(Activity::class)->create([
'happened_at' => now(),
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
// here we should have 2 uniques activity types, one with 3 and the other with 1 occurence
$response = $service->uniqueActivityTypesInTimeRange($contact, now()->subMonths(2), now());
$this->assertCount(
2,
$response
);
$this->assertInstanceOf(
ActivityType::class,
$response[0]['object']
);
$this->assertEquals(
3,
$response[0]['occurences']
);
$this->assertInstanceOf(
ActivityType::class,
$response[1]['object']
);
$this->assertEquals(
1,
$response[1]['occurences']
);
}
/** @test */
public function it_gets_the_breakdown_of_activities_per_year()
{
$service = new ActivityStatisticService;
$account = factory(Account::class)->create();
$contact = factory(Contact::class)->create([
'account_id' => $account->id,
]);
for ($i = 0; $i <= 2; $i++) {
$activity = factory(Activity::class)->create([
'happened_at' => now()->subYears(2),
'account_id' => $account->id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
}
for ($i = 0; $i <= 5; $i++) {
$activity = factory(Activity::class)->create([
'happened_at' => now(),
'account_id' => $account->id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
}
$activityStatistic = $contact->activityStatistics()->make();
$activityStatistic->account_id = $contact->account_id;
$activityStatistic->contact_id = $contact->id;
$activityStatistic->year = now()->year;
$activityStatistic->count = 6;
$activityStatistic->save();
$activityStatistic = $contact->activityStatistics()->make();
$activityStatistic->account_id = $contact->account_id;
$activityStatistic->contact_id = $contact->id;
$activityStatistic->year = now()->subYears(2)->year;
$activityStatistic->count = 3;
$activityStatistic->save();
$response = $service->activitiesPerYearWithContact($contact);
$this->assertCount(
2,
$response
);
$this->assertEquals(
6,
$response[0]->count
);
$this->assertEquals(
3,
$response[1]->count
);
$this->assertInstanceOf(
ActivityStatistic::class,
$response[0]
);
}
/** @test */
public function it_gets_a_list_of_activities_per_month_for_given_year()
{
$service = new ActivityStatisticService;
$account = factory(Account::class)->create();
$contact = factory(Contact::class)->create([
'account_id' => $account->id,
]);
Carbon::setTestNow(Carbon::create(2017, 1, 1));
for ($i = 0; $i <= 2; $i++) {
$activity = factory(Activity::class)->create([
'happened_at' => '2017-01-02',
'account_id' => $account->id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
}
for ($i = 0; $i <= 5; $i++) {
$activity = factory(Activity::class)->create([
'happened_at' => '2017-02-01',
'account_id' => $account->id,
]);
$contact->activities()->attach($activity, ['account_id' => $contact->account_id]);
}
$response = $service->activitiesPerMonthForYear($contact, 2017);
$this->assertCount(
12,
$response
);
$this->assertEquals(
1,
$response[0]['month']
);
$this->assertEquals(
3,
$response[0]['occurences']
);
$this->assertEquals(
2,
$response[1]['month']
);
$this->assertEquals(
6,
$response[1]['occurences']
);
$this->assertInstanceOf(
Activity::class,
$response[1]['activities'][0]
);
}
}

View File

@@ -0,0 +1,76 @@
<?php
namespace Tests\Unit\Services\Account\Activity\ActivityType;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Account\ActivityType;
use App\Models\Account\ActivityTypeCategory;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\ActivityType\CreateActivityType;
class CreateActivityTypeTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_stores_an_activity_type()
{
$account = factory(Account::class)->create([]);
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([
'account_id' => $account->id,
]);
$request = [
'account_id' => $account->id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => 'central perk',
'translation_key' => 'central_perk',
];
$activityType = app(CreateActivityType::class)->execute($request);
$this->assertDatabaseHas('activity_types', [
'id' => $activityType->id,
'account_id' => $account->id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => 'central perk',
'translation_key' => 'central_perk',
]);
$this->assertInstanceOf(
ActivityType::class,
$activityType
);
}
/** @test */
public function it_fails_if_wrong_parameters_are_given()
{
$request = [
'name' => '199 Lafayette Street',
];
$this->expectException(ValidationException::class);
app(CreateActivityType::class)->execute($request);
}
/** @test */
public function it_fails_if_activity_type_category_is_not_linked_to_account()
{
$account = factory(Account::class)->create([]);
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([]);
$request = [
'account_id' => $account->id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => 'central perk',
'translation_key' => 'central_perk',
];
$this->expectException(ModelNotFoundException::class);
app(CreateActivityType::class)->execute($request);
}
}

View File

@@ -0,0 +1,60 @@
<?php
namespace Tests\Unit\Services\Account\Activity\ActivityType;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Account\ActivityType;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\ActivityType\DestroyActivityType;
class DestroyActivityTypeTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_destroys_a_activity_type()
{
$activityType = factory(ActivityType::class)->create([]);
$request = [
'account_id' => $activityType->account_id,
'activity_type_id' => $activityType->id,
];
app(DestroyActivityType::class)->execute($request);
$this->assertDatabaseMissing('activity_types', [
'id' => $activityType->id,
]);
}
/** @test */
public function it_throws_an_exception_if_account_is_not_linked_to_activity_type()
{
$account = factory(Account::class)->create([]);
$activityType = factory(ActivityType::class)->create([]);
$request = [
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
];
$this->expectException(ModelNotFoundException::class);
app(DestroyActivityType::class)->execute($request);
}
/** @test */
public function it_throws_an_exception_if_ids_do_not_exist()
{
$request = [
'account_id' => 11111111,
'activity_type_id' => 11111111,
];
$this->expectException(ValidationException::class);
app(DestroyActivityType::class)->execute($request);
}
}

View File

@@ -0,0 +1,86 @@
<?php
namespace Tests\Unit\Services\Account\Activity\ActivityType;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Account\ActivityType;
use App\Models\Account\ActivityTypeCategory;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\ActivityType\UpdateActivityType;
class UpdateActivityTypeTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_updates_an_activity_type()
{
$activityType = factory(ActivityType::class)->create([]);
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([
'account_id' => $activityType->account_id,
]);
$request = [
'account_id' => $activityType->account_id,
'activity_type_id' => $activityType->id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => 'Chandler House',
'translation_key' => 'https://centralperk.com',
];
$activityType = app(UpdateActivityType::class)->execute($request);
$this->assertDatabaseHas('activity_types', [
'id' => $activityType->id,
'account_id' => $activityType->account_id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => 'Chandler House',
'translation_key' => 'https://centralperk.com',
]);
$this->assertInstanceOf(
ActivityType::class,
$activityType
);
}
/** @test */
public function it_fails_if_wrong_parameters_are_given()
{
$activityType = factory(ActivityType::class)->create([]);
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([
'account_id' => $activityType->account_id,
]);
$request = [
'account_id' => $activityType->account_id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => 'Chandler House',
'translation_key' => 'https://centralperk.com',
];
$this->expectException(ValidationException::class);
app(UpdateActivityType::class)->execute($request);
}
/** @test */
public function it_throws_an_exception_if_activity_is_not_linked_to_account()
{
$account = factory(Account::class)->create([]);
$activityType = factory(ActivityType::class)->create([]);
$request = [
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
'activity_type_category_id' => $activityType->activity_type_category_id,
'name' => 'Chandler House',
'translation_key' => 'https://centralperk.com',
];
$this->expectException(ModelNotFoundException::class);
app(UpdateActivityType::class)->execute($request);
}
}

View File

@@ -0,0 +1,52 @@
<?php
namespace Tests\Unit\Services\Account\Activity\ActivityTypeCategory;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Account\ActivityTypeCategory;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use App\Services\Account\Activity\ActivityTypeCategory\CreateActivityTypeCategory;
class CreateActivityTypeCategoryTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_stores_an_activity_type_category()
{
$account = factory(Account::class)->create([]);
$request = [
'account_id' => $account->id,
'name' => 'central perk',
'translation_key' => 'central_perk',
];
$activityTypeCategory = app(CreateActivityTypeCategory::class)->execute($request);
$this->assertDatabaseHas('activity_type_categories', [
'id' => $activityTypeCategory->id,
'account_id' => $account->id,
'name' => 'central perk',
'translation_key' => 'central_perk',
]);
$this->assertInstanceOf(
ActivityTypeCategory::class,
$activityTypeCategory
);
}
/** @test */
public function it_fails_if_wrong_parameters_are_given()
{
$request = [
'name' => '199 Lafayette Street',
];
$this->expectException(ValidationException::class);
app(CreateActivityTypeCategory::class)->execute($request);
}
}

View File

@@ -0,0 +1,60 @@
<?php
namespace Tests\Unit\Services\Account\Activity\ActivityTypeCategory;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Account\ActivityTypeCategory;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\ActivityTypeCategory\DestroyActivityTypeCategory;
class DestroyActivityTypeCategoryTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_destroys_a_activity_type_category()
{
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([]);
$request = [
'account_id' => $activityTypeCategory->account_id,
'activity_type_category_id' => $activityTypeCategory->id,
];
app(DestroyActivityTypeCategory::class)->execute($request);
$this->assertDatabaseMissing('activity_type_categories', [
'id' => $activityTypeCategory->id,
]);
}
/** @test */
public function it_throws_an_exception_if_account_is_not_linked_to_activity_type_category()
{
$account = factory(Account::class)->create([]);
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([]);
$request = [
'account_id' => $account->id,
'activity_type_category_id' => $activityTypeCategory->id,
];
$this->expectException(ModelNotFoundException::class);
app(DestroyActivityTypeCategory::class)->execute($request);
}
/** @test */
public function it_throws_an_exception_if_ids_do_not_exist()
{
$request = [
'account_id' => 11111111,
'activity_type_category_id' => 11111111,
];
$this->expectException(ValidationException::class);
app(DestroyActivityTypeCategory::class)->execute($request);
}
}

View File

@@ -0,0 +1,72 @@
<?php
namespace Tests\Unit\Services\Account\Activity\ActivityTypeCategory;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Account\ActivityTypeCategory;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\ActivityTypeCategory\UpdateActivityTypeCategory;
class UpdateActivityTypeCategoryTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_updates_a_activity_type_category()
{
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([]);
$request = [
'account_id' => $activityTypeCategory->account_id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => 'Chandler House',
'translation_key' => 'https://centralperk.com',
];
$activityTypeCategory = app(UpdateActivityTypeCategory::class)->execute($request);
$this->assertDatabaseHas('activity_type_categories', [
'id' => $activityTypeCategory->id,
'account_id' => $activityTypeCategory->account_id,
'name' => 'Chandler House',
'translation_key' => 'https://centralperk.com',
]);
$this->assertInstanceOf(
ActivityTypeCategory::class,
$activityTypeCategory
);
}
/** @test */
public function it_fails_if_wrong_parameters_are_given()
{
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([]);
$request = [
'name' => '199 Lafayette Street',
];
$this->expectException(ValidationException::class);
app(UpdateActivityTypeCategory::class)->execute($request);
}
/** @test */
public function it_throws_an_exception_if_activity_is_not_linked_to_account()
{
$account = factory(Account::class)->create([]);
$activityTypeCategory = factory(ActivityTypeCategory::class)->create([]);
$request = [
'account_id' => $account->id,
'activity_type_category_id' => $activityTypeCategory->id,
'name' => '199 Lafayette Street',
];
$this->expectException(ModelNotFoundException::class);
app(UpdateActivityTypeCategory::class)->execute($request);
}
}

View File

@@ -0,0 +1,99 @@
<?php
namespace Tests\Unit\Services\Account\Activity;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Contact\Contact;
use App\Models\Account\Activity;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\Activity\AttachContactToActivity;
class AttachContactToActivityTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_attaches_contacts()
{
$activity = factory(Activity::class)->create([]);
$contactA = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$contactB = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$contactC = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$request = [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contacts' => [$contactA->id, $contactB->id, $contactC->id],
];
$activity = app(AttachContactToActivity::class)->execute($request);
$this->assertDatabaseHas('activity_contact', [
'activity_id' => $activity->id,
'contact_id' => $contactA->id,
'account_id' => $activity->account_id,
]);
$this->assertDatabaseHas('activity_contact', [
'activity_id' => $activity->id,
'contact_id' => $contactB->id,
'account_id' => $activity->account_id,
]);
$this->assertDatabaseHas('activity_contact', [
'activity_id' => $activity->id,
'contact_id' => $contactC->id,
'account_id' => $activity->account_id,
]);
$this->assertInstanceOf(
Activity::class,
$activity
);
}
/** @test */
public function it_fails_if_wrong_parameters_are_given()
{
$activity = factory(Activity::class)->create([]);
$contactA = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$request = [
'activity_id' => $activity->id,
'contacts' => [$contactA->id],
];
$this->expectException(ValidationException::class);
app(AttachContactToActivity::class)->execute($request);
}
/** @test */
public function it_throws_an_exception_if_contact_is_not_linked_to_account()
{
$activity = factory(Activity::class)->create([]);
$account = factory(Account::class)->create([]);
$contactA = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$request = [
'activity_id' => $activity->id,
'account_id' => $account->id,
'contacts' => [$contactA->id],
];
$this->expectException(ModelNotFoundException::class);
app(AttachContactToActivity::class)->execute($request);
}
}

View File

@@ -0,0 +1,149 @@
<?php
namespace Tests\Unit\Services\Account\Activity;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Contact\Contact;
use App\Models\Account\Activity;
use App\Models\Account\ActivityType;
use App\Models\Instance\Emotion\Emotion;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\Activity\CreateActivity;
class CreateActivityTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_stores_an_activity_and_creates_an_entry_in_the_journal()
{
$account = factory(Account::class)->create();
$contacts = factory(Contact::class, 3)->create([
'account_id' => $account->id,
]);
$activityType = factory(ActivityType::class)->create([
'account_id' => $account->id,
]);
$request = [
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'contacts' => $contacts->map(function ($contact) {
return $contact->id;
})->toArray(),
];
$activity = app(CreateActivity::class)->execute($request);
$this->assertDatabaseHas('activities', [
'id' => $activity->id,
'account_id' => $account->id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
]);
foreach ($contacts as $contact) {
$this->assertDatabaseHas('activity_contact', [
'account_id' => $account->id,
'activity_id' => $activity->id,
'contact_id' => $contact->id,
]);
}
$this->assertInstanceOf(
Activity::class,
$activity
);
$this->assertDatabaseHas('journal_entries', [
'account_id' => $account->id,
'journalable_id' => $activity->id,
'journalable_type' => get_class($activity),
]);
}
/** @test */
public function it_adds_emotions()
{
$account = factory(Account::class)->create();
$contact = factory(Contact::class)->create([
'account_id' => $account->id,
]);
$emotion = factory(Emotion::class)->create([]);
$emotion2 = factory(Emotion::class)->create([]);
$emotionArray = [];
$emotionArray[] = $emotion->id;
$emotionArray[] = $emotion2->id;
$activityType = factory(ActivityType::class)->create([
'account_id' => $account->id,
]);
$request = [
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'emotions' => $emotionArray,
'contacts' => [$contact->id],
];
$activity = app(CreateActivity::class)->execute($request);
$this->assertDatabaseHas('emotion_activity', [
'account_id' => $account->id,
'activity_id' => $activity->id,
'emotion_id' => $emotion->id,
]);
$this->assertDatabaseHas('emotion_activity', [
'account_id' => $account->id,
'activity_id' => $activity->id,
'emotion_id' => $emotion2->id,
]);
}
/** @test */
public function it_fails_if_wrong_parameters_are_given()
{
$account = factory(Account::class)->create([]);
$request = [
'account_id' => $account->id,
];
$this->expectException(ValidationException::class);
app(CreateActivity::class)->execute($request);
}
/** @test */
public function it_throws_an_exception_if_activity_type_is_not_linked_to_account()
{
$account = factory(Account::class)->create([]);
$activityType = factory(ActivityType::class)->create([]);
$contact = factory(Contact::class)->create([
'account_id' => $account->id,
]);
$request = [
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'contacts' => [$contact->id],
];
$this->expectException(ModelNotFoundException::class);
app(CreateActivity::class)->execute($request);
}
}

View File

@@ -0,0 +1,94 @@
<?php
namespace Tests\Unit\Services\Account\Activity;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Contact\Contact;
use App\Models\Account\Activity;
use App\Models\Account\ActivityType;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use App\Services\Account\Activity\Activity\CreateActivity;
use App\Services\Account\Activity\Activity\DestroyActivity;
class DestroyActivityTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_destroys_a_activity()
{
$activity = factory(Activity::class)->create([]);
$request = [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
];
$this->assertDatabaseHas('activities', [
'id' => $activity->id,
]);
app(DestroyActivity::class)->execute($request);
$this->assertDatabaseMissing('activities', [
'id' => $activity->id,
]);
}
/** @test */
public function it_removes_the_journal_entry_when_destroying_the_activity()
{
$account = factory(Account::class)->create([]);
$activityType = factory(ActivityType::class)->create([
'account_id' => $account->id,
]);
$contact = factory(Contact::class)->create([
'account_id' => $account->id,
]);
$request = [
'account_id' => $account->id,
'activity_type_id' => $activityType->id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'contacts' => [$contact->id],
];
$activity = app(CreateActivity::class)->execute($request);
$this->assertDatabaseHas('activities', [
'id' => $activity->id,
]);
$this->assertDatabaseHas('activity_contact', [
'activity_id' => $activity->id,
'contact_id' => $contact->id,
]);
$this->assertDatabaseHas('journal_entries', [
'account_id' => $account->id,
'journalable_id' => $activity->id,
'journalable_type' => get_class($activity),
]);
$request = [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
];
app(DestroyActivity::class)->execute($request);
$this->assertDatabaseMissing('activities', [
'id' => $activity->id,
]);
$this->assertDatabaseMissing('activity_contact', [
'activity_id' => $activity->id,
]);
$this->assertDatabaseMissing('journal_entries', [
'account_id' => $account->id,
'journalable_id' => $activity->id,
'journalable_type' => get_class($activity),
]);
}
}

View File

@@ -0,0 +1,191 @@
<?php
namespace Tests\Unit\Services\Account\Activity;
use Tests\TestCase;
use App\Models\Account\Account;
use App\Models\Contact\Contact;
use App\Models\Account\Activity;
use Illuminate\Validation\ValidationException;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use App\Services\Account\Activity\Activity\UpdateActivity;
class UpdateActivityTest extends TestCase
{
use DatabaseTransactions;
/** @test */
public function it_updates_an_activity()
{
$activity = factory(Activity::class)->create([]);
$contact = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$request = [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'activity_type_id' => $activity->activity_type_id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'contacts' => [$contact->id],
];
app(UpdateActivity::class)->execute($request);
$this->assertDatabaseHas('activities', [
'id' => $activity->id,
'account_id' => $activity->account_id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
]);
$this->assertInstanceOf(
Activity::class,
$activity
);
}
/** @test */
public function it_removes_old_associated_contacts()
{
$activity = factory(Activity::class)->create();
$contacts = factory(Contact::class, 3)->create([
'account_id' => $activity->account_id,
]);
foreach ($contacts as $contact) {
$activity->contacts()->syncWithoutDetaching([$contact->id => [
'account_id' => $activity->account_id,
]]);
}
foreach ($contacts as $contact) {
$this->assertDatabaseHas('activity_contact', [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contact_id' => $contact->id,
]);
}
$newContact = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$request = [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'activity_type_id' => $activity->activity_type_id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'contacts' => [$newContact->id],
];
app(UpdateActivity::class)->execute($request);
$this->assertDatabaseHas('activity_contact', [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contact_id' => $newContact->id,
]);
foreach ($contacts as $contact) {
$this->assertDatabaseMissing('activity_contact', [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contact_id' => $contact->id,
]);
}
}
/** @test */
public function it_removes_old_associated_contacts_and_keep_previous_one()
{
$activity = factory(Activity::class)->create();
$contacts = factory(Contact::class, 3)->create([
'account_id' => $activity->account_id,
]);
foreach ($contacts as $contact) {
$activity->contacts()->syncWithoutDetaching([$contact->id => [
'account_id' => $activity->account_id,
]]);
}
foreach ($contacts as $contact) {
$this->assertDatabaseHas('activity_contact', [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contact_id' => $contact->id,
]);
}
$request = [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'activity_type_id' => $activity->activity_type_id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'contacts' => [$contacts[0]->id, $contacts[1]->id],
];
app(UpdateActivity::class)->execute($request);
$this->assertDatabaseHas('activity_contact', [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contact_id' => $contacts[0]->id,
]);
$this->assertDatabaseHas('activity_contact', [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contact_id' => $contacts[1]->id,
]);
$this->assertDatabaseMissing('activity_contact', [
'account_id' => $activity->account_id,
'activity_id' => $activity->id,
'contact_id' => $contacts[2]->id,
]);
}
/** @test */
public function it_fails_if_wrong_parameters_are_given()
{
$activity = factory(Activity::class)->create([]);
$request = [
'activity_id' => $activity->id,
'activity_type_id' => $activity->activity_type_id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
];
$this->expectException(ValidationException::class);
app(UpdateActivity::class)->execute($request);
}
/** @test */
public function it_throws_an_exception_if_contact_is_not_linked_to_account()
{
$activity = factory(Activity::class)->create([]);
$account = factory(Account::class)->create([]);
$contact = factory(Contact::class)->create([
'account_id' => $activity->account_id,
]);
$request = [
'account_id' => $account->id,
'activity_id' => $activity->id,
'activity_type_id' => $activity->activity_type_id,
'summary' => 'we went to central perk',
'description' => 'it was awesome',
'happened_at' => '2009-09-09',
'contacts' => [$contact->id],
];
$this->expectException(ModelNotFoundException::class);
app(UpdateActivity::class)->execute($request);
}
}