public function testName()
{
$name = 'testName';
$this->assertNull($this->organization->getName());
$this->organization->setName($name);
$this->assertEquals($name, $this->organization->getName());
$this->assertEquals($name, (string) $this->organization);
}
/**
* Test existing user modification
*/
public function testOnFlushUpdateUser()
{
$args = new OnFlushEventArgs($this->em);
$user = new User();
$org = new Organization();
$org->setId(1);
$org->setName('test');
$user->addOrganization($org);
$newCalendar = new Calendar();
$newCalendar->setOwner($user);
$newCalendar->setOrganization($org);
$newConnection = new CalendarConnection($newCalendar);
$newCalendar->addConnection($newConnection);
$calendarMetadata = new ClassMetadata(get_class($newCalendar));
$connectionMetadata = new ClassMetadata(get_class($newConnection));
$this->em->expects($this->any())->method('getClassMetadata')->will($this->returnValueMap([['Oro\\Bundle\\CalendarBundle\\Entity\\Calendar', $calendarMetadata], ['Oro\\Bundle\\CalendarBundle\\Entity\\CalendarConnection', $connectionMetadata]]));
$calendarRepo = $this->getMockBuilder('\\Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$calendarRepo->expects($this->any())->method('findDefaultCalendar')->will($this->returnValue(false));
$this->em->expects($this->once())->method('getUnitOfWork')->will($this->returnValue($this->uow));
$this->uow->expects($this->once())->method('getScheduledEntityInsertions')->will($this->returnValue([]));
$this->uow->expects($this->once())->method('getScheduledEntityUpdates')->will($this->returnValue([$user]));
$this->em->expects($this->any())->method('getRepository')->with('OroCalendarBundle:Calendar')->will($this->returnValue($calendarRepo));
$this->em->expects($this->at(2))->method('persist')->with($this->equalTo($newCalendar));
$this->em->expects($this->at(3))->method('persist')->with($this->equalTo($newConnection));
$this->uow->expects($this->at(2))->method('computeChangeSet')->with($calendarMetadata, $newCalendar);
$this->uow->expects($this->at(3))->method('computeChangeSet')->with($connectionMetadata, $newConnection);
$this->listener->onFlush($args);
}
public function testGetActivityOwners()
{
$organization = new Organization();
$organization->setName('Org');
$user = new User();
$user->setUsername('test');
$emailUser = new EmailUser();
$emailUser->setOrganization($organization);
$emailUser->setOwner($user);
$owners = [$emailUser];
$emailMock = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailUser')->setMethods(['getFromEmailAddress', 'hasOwner', 'getOwner', 'getOrganization', 'getActivityTargetEntities'])->disableOriginalConstructor()->getMock();
$emailMock->expects($this->once())->method('getFromEmailAddress')->willReturn($emailMock);
$emailMock->expects($this->once())->method('getOwner')->willReturn($emailMock);
$emailMock->expects($this->exactly(2))->method('getOrganization')->willReturn($organization);
$emailMock->expects($this->exactly(1))->method('getActivityTargetEntities')->willReturn([]);
$activityListMock = $this->getMockBuilder('Oro\\Bundle\\ActivityListBundle\\Entity\\ActivityList')->disableOriginalConstructor()->getMock();
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$repository = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$this->doctrineRegistryLink->expects($this->once())->method('getService')->willReturn($em);
$em->expects($this->once())->method('getRepository')->willReturn($repository);
$repository->expects($this->once())->method('findBy')->willReturn($owners);
$activityOwnerArray = $this->emailActivityListProvider->getActivityOwners($emailMock, $activityListMock);
$this->assertCount(1, $activityOwnerArray);
$owner = $activityOwnerArray[0];
$this->assertEquals($organization->getName(), $owner->getOrganization()->getName());
$this->assertEquals($user->getUsername(), $owner->getUser()->getUsername());
}
public function load(ObjectManager $manager)
{
$defaultOrganization = new Organization();
$defaultOrganization->setName('default')->setCurrency('USD')->setPrecision('000 000.00');
$this->addReference('default_organization', $defaultOrganization);
$manager->persist($defaultOrganization);
$manager->flush();
}
public function testSetGetOrganizationContext()
{
$this->assertEmpty($this->token->getOrganizationContext());
$organization = new Organization();
$organization->setName('test');
$this->token->setOrganizationContext($organization);
$this->assertEquals($organization, $this->token->getOrganizationContext());
}
/**
* @param string $key
* @param Organization $entity
*/
public function fillEntityData($key, $entity)
{
switch ($key) {
case 'default':
$organization = $this->securityFacade->getOrganization();
if ($organization) {
$entity->setName($organization->getName());
}
return;
}
parent::fillEntityData($key, $entity);
}
public function testGetVariableValues()
{
$organization = new Organization();
$organization->setName('TestOrg');
$user = new User();
$user->setUsername('test');
$user->setFirstName('FirstName');
$user->setLastName('LastName');
$this->securityFacade->expects($this->once())->method('getOrganization')->will($this->returnValue($organization));
$this->securityFacade->expects($this->once())->method('getLoggedUser')->will($this->returnValue($user));
$this->nameFormatter->expects($this->once())->method('format')->with($this->identicalTo($user))->will($this->returnValue('FullName'));
$result = $this->provider->getVariableValues();
$this->assertEquals(['userName' => 'test', 'userFirstName' => 'FirstName', 'userLastName' => 'LastName', 'userFullName' => 'FullName', 'organizationName' => 'TestOrg'], $result);
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
// load default organization
$defaultOrganization = new Organization();
$defaultOrganization->setName(self::MAIN_ORGANIZATION)->setEnabled(true);
$this->addReference('default_organization', $defaultOrganization);
$manager->persist($defaultOrganization);
// load default business unit
$defaultBusinessUnit = new BusinessUnit();
$defaultBusinessUnit->setName(self::MAIN_BUSINESS_UNIT)->setOrganization($defaultOrganization);
$this->addReference('default_business_unit', $defaultBusinessUnit);
$manager->persist($defaultBusinessUnit);
$manager->flush();
}
public function testCreateCustomer()
{
$organization = new Organization();
$organization->setName('test');
$user = $this->getUser();
$user->setOrganization($organization)->setFirstName('John')->setLastName('Doe');
$this->assertEmpty($user->getCustomer());
// createCustomer is triggered on prePersist event
$user->createCustomer();
$customer = $user->getCustomer();
$this->assertInstanceOf('OroB2B\\Bundle\\CustomerBundle\\Entity\\Customer', $customer);
$this->assertEquals($organization, $customer->getOrganization());
$this->assertEquals('John Doe', $customer->getName());
// new customer created only if it not defined
$user->setFirstName('Jane');
$user->createCustomer();
$this->assertEquals('John Doe', $user->getCustomer()->getName());
}
/**
* {@inheritdoc}
* @dataProvider supportedMethods
*/
public function testProcessSupportedRequest($method, $isValid, $isProcessed)
{
$organization = null;
if ($isValid) {
$organization = new Organization();
$organization->setName('test');
$organizationToken = $this->getMock('Oro\\Bundle\\SecurityBundle\\Authentication\\Token\\OrganizationContextTokenInterface');
$organizationToken->expects($this->any())->method('getOrganizationContext')->willReturn($organization);
$this->securityFacade->expects($this->any())->method('getToken')->willReturn($organizationToken);
$this->form->expects($this->at(2))->method('get')->with('passwordGenerate')->will($this->returnValue($this->passwordGenerateForm));
$this->form->expects($this->at(3))->method('get')->with('sendEmail')->will($this->returnValue($this->sendEmailForm));
$this->passwordGenerateForm->expects($this->once())->method('getData')->will($this->returnValue(false));
$this->sendEmailForm->expects($this->once())->method('getData')->will($this->returnValue(false));
}
$this->form->expects($this->any())->method('isValid')->will($this->returnValue($isValid));
$this->request->setMethod($method);
$this->form->expects($this->once())->method('submit')->with($this->request);
$this->assertEquals($isProcessed, $this->handler->process($this->entity));
if ($organization) {
$this->assertEquals($organization, $this->entity->getOrganization());
$this->assertTrue($this->entity->hasOrganization($organization));
}
}
public function testCreateAccount()
{
$organization = new Organization();
$organization->setName('test');
$user = $this->getUser();
$user->setOrganization($organization)->setFirstName('John')->setLastName('Doe')->setOwner(new User());
$this->assertEmpty($user->getAccount());
$address = new AccountAddress();
$user->addAddress($address);
$this->assertContains($address, $user->getAddresses());
$backendUser = new User();
$user->setOwner($backendUser);
$this->assertEquals($user->getOwner(), $backendUser);
// createAccount is triggered on prePersist event
$user->createAccount();
$account = $user->getAccount();
$this->assertInstanceOf('OroB2B\\Bundle\\AccountBundle\\Entity\\Account', $account);
$this->assertEquals($organization, $account->getOrganization());
$this->assertEquals('John Doe', $account->getName());
// new account created only if it not defined
$user->setFirstName('Jane');
$user->createAccount();
$this->assertEquals('John Doe', $user->getAccount()->getName());
}
/**
* @param string $accountName
* @param string $userFirstName
* @param string $userLastName
* @param bool $isOrder
* @return Order|Quote
*/
protected function createMainEntity($accountName, $userFirstName, $userLastName, $isOrder = false)
{
$accountUser = $this->createAccountUser($accountName);
$owner = new User();
$owner->setFirstName($userFirstName . ' owner')->setLastName($userLastName . ' owner')->setSalt(null);
$organization = new Organization();
$organization->setName($userFirstName . ' ' . $userLastName . ' org');
$entity = $isOrder ? new Order() : new Quote();
$entity->setAccount($accountUser->getAccount())->setAccountUser($accountUser)->setOwner($owner)->setOrganization($organization);
return $entity;
}
public function testGetApiKey()
{
$entity = $this->getUser();
$this->assertEmpty($entity->getApiKeys(), 'Should return some key, even if is not present');
$organization1 = new Organization();
$organization1->setName('test1');
$organization2 = new Organization();
$organization2->setName('test2');
$apiKey1 = new UserApi();
$apiKey1->setApiKey($apiKey1->generateKey());
$apiKey1->setOrganization($organization1);
$apiKey2 = new UserApi();
$apiKey2->setApiKey($apiKey2->generateKey());
$apiKey2->setOrganization($organization2);
$entity->addApiKey($apiKey1);
$entity->addApiKey($apiKey2);
$this->assertSame($apiKey1->getApiKey(), $entity->getApiKeys()[0]->getApiKey(), 'Should delegate call to userApi entity');
$this->assertEquals(new ArrayCollection([$apiKey1, $apiKey2]), $entity->getApiKeys());
$entity->removeApiKey($apiKey2);
$this->assertEquals(new ArrayCollection([$apiKey1]), $entity->getApiKeys());
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage User test_user is not in organization test_organization
*/
public function testUserNotInOrganization()
{
$username = '******';
$user = new User();
$user->setUsername($username);
$organizationName = 'test_organization';
$organization = new Organization();
$organization->setName($organizationName);
$organization->setEnabled(true);
$event = $this->getEvent();
/** @var \PHPUnit_Framework_MockObject_MockObject $input */
$input = $event->getInput();
$input->expects($this->at(0))->method('getParameterOption')->with('--' . ConsoleContextListener::OPTION_USER)->will($this->returnValue($username));
$input->expects($this->at(1))->method('getParameterOption')->with('--' . ConsoleContextListener::OPTION_ORGANIZATION)->will($this->returnValue($organizationName));
$this->userManager->expects($this->once())->method('findUserByUsernameOrEmail')->with($username)->will($this->returnValue($user));
$this->organizationRepository->expects($this->once())->method('findOneBy')->with(['name' => $organizationName])->will($this->returnValue($organization));
$this->listener->onConsoleCommand($event);
}
public function testGetApiKey()
{
/** @var User $entity */
$entity = new User();
$this->assertNotEmpty($entity->getApiKeys(), 'Should return some key, even if is not present');
$key1 = $entity->getApiKeys();
usleep(1);
// need because 'uniqid' generates a unique identifier based on the current time in microseconds
$this->assertNotSame($key1, $entity->getApiKeys(), 'Should return unique random string');
$organization1 = new Organization();
$organization1->setName('test1');
$organization2 = new Organization();
$organization2->setName('test2');
$apiKey1 = new UserApi();
$apiKey1->setApiKey($apiKey1->generateKey());
$apiKey1->setOrganization($organization1);
$apiKey2 = new UserApi();
$apiKey2->setApiKey($apiKey2->generateKey());
$apiKey2->setOrganization($organization2);
$entity->addApiKey($apiKey1);
$entity->addApiKey($apiKey2);
$this->assertSame($apiKey1->getApiKey(), $entity->getApiKeys()[0]->getApiKey(), 'Should delegate call to userApi entity');
$this->assertEquals(new ArrayCollection([$apiKey1, $apiKey2]), $entity->getApiKeys());
}
public function testActivityOwner()
{
$user = new User();
$user->setFirstName('First Name');
$organization = new Organization();
$organization->setName('Organization One');
$activityOwner = new ActivityOwner();
$activityOwner->setUser($user);
$activityOwner->setOrganization($organization);
$activityList = new ActivityList();
$activityList->addActivityOwner($activityOwner);
$this->assertCount(1, $activityList->getActivityOwners());
$firstOwner = $activityList->getActivityOwners()->first();
$this->assertEquals('First Name', $firstOwner->getUser()->getFirstName());
$this->assertEquals('Organization One', $firstOwner->getOrganization()->getName());
}
