def test_sync_all_accounts_teams_inactive_entity_kind(self):
        """
        Tests syncing of all accounts when they have super entities and the entiity kind is inactive
        """
        # Create five test accounts
        accounts = [Account.objects.create() for i in range(5)]
        # Create two teams to assign to some of the accounts
        teams = [Team.objects.create() for i in range(2)]
        accounts[0].team = teams[0]
        accounts[0].save()
        accounts[1].team = teams[0]
        accounts[1].save()
        accounts[2].team = teams[1]
        accounts[2].save()
        accounts[3].team = teams[1]
        accounts[3].save()

        team_ek = EntityKind.objects.get(name='tests.team')
        team_ek.delete()

        # Sync all the entities. There should be 7 (5 accounts 2 teams)
        sync_entities()
        self.assertEquals(
            Entity.objects.filter(entity_type=ContentType.objects.
                                  get_for_model(Account)).count(), 5)
        self.assertEquals(
            Entity.objects.filter(
                entity_type=ContentType.objects.get_for_model(Team)).count(),
            2)
        self.assertEquals(Entity.objects.all().count(), 7)

        # There should be four entity relationships since four accounts have teams
        self.assertEquals(EntityRelationship.objects.all().count(), 4)
Beispiel #2
0
def run():
    print("importing player data now")
    
    with open('./../resources/NFL Salary Visualization - nfl_salaries.csv', newline='') as csvfile:
        reader = csv.DictReader(csvfile)
        for row in reader:
            first_name = row['player'].split(' ')[0]
            last_name = row['player'].split(' ')[1]
            salary = row['salary']
            team_name = teams.teams[row['team']]
            position_name = positions.positions[row['position']]

            team = Team.objects.filter(name=team_name).first()
            if not team:
                team = Team(name=team_name, name_abbreviated=row['team'])
                team.save()


            position = Position.objects.filter(name=position_name).first()
            if not position:
                position = Position(name=position_name, name_abbreviated=row['position'])
                position.save()
            
            player = Player(
                email='{}.{}@{}.net'.format(first_name, last_name, team.name_abbreviated),
                first_name=first_name,
                password='******',
                last_name=last_name,
                position=position,
                team=team,
                salary=int(salary))
            player.save()
    print('syncing now')
    sync_entities()
Beispiel #3
0
    def test_sync_all_accounts_teams_inactive_entity_kind(self):
        """
        Tests syncing of all accounts when they have super entities and the entiity kind is inactive
        """
        # Create five test accounts
        accounts = [Account.objects.create() for i in range(5)]
        # Create two teams to assign to some of the accounts
        teams = [Team.objects.create() for i in range(2)]
        accounts[0].team = teams[0]
        accounts[0].save()
        accounts[1].team = teams[0]
        accounts[1].save()
        accounts[2].team = teams[1]
        accounts[2].save()
        accounts[3].team = teams[1]
        accounts[3].save()

        team_ek = EntityKind.objects.get(name='tests.team')
        team_ek.delete()

        # Sync all the entities. There should be 7 (5 accounts 2 teams)
        sync_entities()
        self.assertEquals(Entity.objects.filter(entity_type=ContentType.objects.get_for_model(Account)).count(), 5)
        self.assertEquals(Entity.objects.filter(entity_type=ContentType.objects.get_for_model(Team)).count(), 2)
        self.assertEquals(Entity.objects.all().count(), 7)

        # There should be four entity relationships since four accounts have teams
        self.assertEquals(EntityRelationship.objects.all().count(), 4)
    def test_sync_all_optimal_queries(self):
        """
        Tests optimal queries of syncing all entities.
        """
        # Create five test accounts
        accounts = [Account.objects.create() for i in range(5)]
        # Create two teams to assign to some of the accounts
        teams = [Team.objects.create() for i in range(2)]
        accounts[0].team = teams[0]
        accounts[0].save()
        accounts[1].team = teams[0]
        accounts[1].save()
        accounts[2].team = teams[1]
        accounts[2].save()
        accounts[3].team = teams[1]
        accounts[3].save()

        # Use an entity registry that only has accounts and teams. This ensures that other registered
        # entity models dont pollute the test case
        new_registry = EntityRegistry()
        new_registry.register_entity(AccountConfig)
        new_registry.register_entity(TeamConfig)

        with patch('entity.sync.entity_registry') as mock_entity_registry:
            mock_entity_registry.entity_registry = new_registry.entity_registry
            ContentType.objects.clear_cache()
            with self.assertNumQueries(19):
                sync_entities()

        self.assertEquals(Entity.objects.filter(entity_type=ContentType.objects.get_for_model(Account)).count(), 5)
        self.assertEquals(Entity.objects.filter(entity_type=ContentType.objects.get_for_model(Team)).count(), 2)
        self.assertEquals(Entity.objects.all().count(), 7)

        # There should be four entity relationships since four accounts have teams
        self.assertEquals(EntityRelationship.objects.all().count(), 4)
 def test_sync_multi_inherited_data(self):
     """
     Test when models are synced that don't directly inherit EntityModelMixin.
     """
     # Create an entity that does not directly inherit EntityModelMixin
     MultiInheritEntity.objects.create()
     # Sync all entities and verify that one was created
     sync_entities()
     self.assertEquals(Entity.objects.all().count(), 1)
Beispiel #6
0
 def test_sync_multi_inherited_data(self):
     """
     Test when models are synced that don't directly inherit EntityModelMixin.
     """
     # Create an entity that does not directly inherit EntityModelMixin
     MultiInheritEntity.objects.create()
     # Sync all entities and verify that one was created
     sync_entities()
     self.assertEquals(Entity.objects.all().count(), 1)
Beispiel #7
0
def save_entity_signal_handler(sender, instance, **kwargs):
    """
    Defines a signal handler for saving an entity. Syncs the entity to
    the entity mirror table.
    """
    if instance.__class__ in entity_registry.entity_registry:
        sync_entities(instance)

    if instance.__class__ in entity_registry.entity_watching:
        sync_entities_watching(instance)
def bulk_operation_signal_handler(sender, *args, **kwargs):
    """
    When a bulk operation has happened on a model, sync all the entities again.
    NOTE - bulk syncing isn't turned on by default because of the consequences of it.
    For example, a user may issue a simple update to a single model, which would trigger
    syncing of all entities. It is up to the user to explicitly enable syncing on bulk
    operations with turn_on_syncing(bulk=True)
    """
    if sender in entity_registry.entity_registry:
        sync_entities()
        def test_method(test, count=5, sync_all=False):
            # Create some entities
            for i in range(count):
                Account.objects.create()

            if sync_all:
                sync_entities()

            # Assert that we do not have any entities
            test.assertEquals(Entity.objects.all().count(), 0)
 def test_sync_dummy_data(self):
     """
     Tests that dummy data (i.e data that does not inherit EntityModelMixin) doesn't
     get synced.
     """
     # Create dummy data
     DummyModel.objects.create()
     # Sync all entities and verify that none were created
     sync_entities()
     self.assertEquals(Entity.objects.all().count(), 0)
Beispiel #11
0
 def test_sync_dummy_data(self):
     """
     Tests that dummy data (i.e data that does not inherit EntityModelMixin) doesn't
     get synced.
     """
     # Create dummy data
     DummyModel.objects.create()
     # Sync all entities and verify that none were created
     sync_entities()
     self.assertEquals(Entity.objects.all().count(), 0)
Beispiel #12
0
def bulk_operation_signal_handler(sender, *args, **kwargs):
    """
    When a bulk operation has happened on a model, sync all the entities again.
    NOTE - bulk syncing isn't turned on by default because of the consequences of it.
    For example, a user may issue a simple update to a single model, which would trigger
    syncing of all entities. It is up to the user to explicitly enable syncing on bulk
    operations with turn_on_syncing(bulk=True)
    """
    if sender in entity_registry.entity_registry:
        sync_entities()
Beispiel #13
0
        def test_method(test, count=5, sync_all=False):
            # Create some entities
            for i in range(count):
                Account.objects.create()

            if sync_all:
                sync_entities()

            # Assert that we do not have any entities
            test.assertEquals(Entity.objects.all().count(), 0)
Beispiel #14
0
    def test_sync_two_accounts_one_team_group(self):
        turn_off_syncing()
        team = G(Team)
        account1 = G(Account, team=team)
        account2 = G(Account, team=team)
        team_group = G(TeamGroup)
        sync_entities(account1, account2, team_group)

        self.assertEquals(Entity.objects.count(), 4)
        self.assertEquals(EntityRelationship.objects.count(), 2)
def save_entity_signal_handler(sender, instance, **kwargs):
    """
    Defines a signal handler for saving an entity. Syncs the entity to
    the entity mirror table.
    """
    if instance.__class__ in entity_registry.entity_registry:
        sync_entities(instance)

    if instance.__class__ in entity_registry.entity_watching:
        sync_entities_watching(instance)
    def test_sync_two_accounts_one_team_group(self):
        turn_off_syncing()
        team = G(Team)
        account1 = G(Account, team=team)
        account2 = G(Account, team=team)
        team_group = G(TeamGroup)
        sync_entities(account1, account2, team_group)

        self.assertEquals(Entity.objects.count(), 4)
        self.assertEquals(EntityRelationship.objects.count(), 2)
    def test_get_all_entities_active(self):
        """
        Makes sure only active entity ids are returned
        """
        turn_off_syncing()

        account_type = ContentType.objects.get_for_model(Account)

        # Set up teams
        teams = Team.objects.bulk_create([
            Team()
            for i in range(0, 3)
        ])

        # Set up accounts
        accounts = Account.objects.bulk_create([
            Account(team=teams[i % 3])
            for i in range(0, 20)
        ])
        accounts[0].is_active = False
        accounts[0].save()

        # Turn on syncing and do a sync
        turn_on_syncing()

        sync_entities()

        account_entities = list(Entity.all_objects.filter(entity_type=account_type).order_by('entity_id'))

        # Create groups
        EntityGroup.objects.bulk_create([
            EntityGroup()
            for i in range(0, 6)
        ])

        # Refresh for django 1.9 because bulk create does not return ids
        entity_groups = list(EntityGroup.objects.order_by('id'))

        # Set up individual entity groups
        entity_groups[0].bulk_add_entities([
            [account_entities[0], None],
            [account_entities[1], None],
            [account_entities[2], None],
            [account_entities[3], None],
        ])

        self.assertEqual(len(entity_groups[0].get_all_entities()), 3)
        self.assertEqual(len(entity_groups[0].get_all_entities(is_active=False)), 1)
        self.assertEqual(len(entity_groups[0].get_all_entities(is_active=None)), 4)
Beispiel #18
0
    def test_get_all_entities_active(self):
        """
        Makes sure only active entity ids are returned
        """
        turn_off_syncing()

        account_type = ContentType.objects.get_for_model(Account)

        # Set up teams
        teams = Team.objects.bulk_create([Team() for i in range(0, 3)])

        # Set up accounts
        accounts = Account.objects.bulk_create(
            [Account(team=teams[i % 3]) for i in range(0, 20)])
        accounts[0].is_active = False
        accounts[0].save()

        # Turn on syncing and do a sync
        turn_on_syncing()

        sync_entities()

        account_entities = list(
            Entity.all_objects.filter(
                entity_type=account_type).order_by('entity_id'))

        # Create groups
        EntityGroup.objects.bulk_create([EntityGroup() for i in range(0, 6)])

        # Refresh for django 1.9 because bulk create does not return ids
        entity_groups = list(EntityGroup.objects.order_by('id'))

        # Set up individual entity groups
        entity_groups[0].bulk_add_entities([
            [account_entities[0], None],
            [account_entities[1], None],
            [account_entities[2], None],
            [account_entities[3], None],
        ])

        self.assertEqual(len(entity_groups[0].get_all_entities()), 3)
        self.assertEqual(
            len(entity_groups[0].get_all_entities(is_active=False)), 1)
        self.assertEqual(
            len(entity_groups[0].get_all_entities(is_active=None)), 4)
Beispiel #19
0
    def test_sync_all_account_no_teams(self):
        """
        Tests syncing all accounts with no super entities.
        """
        # Create five test accounts
        accounts = [Account.objects.create() for i in range(5)]

        # Sync all of the entities and verify that five Entity models were created for the Account model
        self.assertEquals(Entity.objects.all().count(), 0)
        sync_entities()
        self.assertEquals(Entity.objects.all().count(), 5)

        # Delete an account. When all entities are synced again,
        # there should only be four accounts
        accounts[0].delete()
        self.assertEquals(Entity.objects.all().count(), 5)
        sync_entities()
        self.assertEquals(Entity.objects.all().count(), 4)
Beispiel #20
0
    def test_sync_optimal_queries(self):
        """
        Tests optimal queries of syncing.
        """
        # Create five test accounts
        accounts = [Account.objects.create() for i in range(5)]
        # Create two teams to assign to some of the accounts
        teams = [Team.objects.create() for i in range(2)]
        accounts[0].team = teams[0]
        accounts[0].save()
        accounts[1].team = teams[0]
        accounts[1].save()
        accounts[2].team = teams[1]
        accounts[2].save()
        accounts[3].team = teams[1]
        accounts[3].save()

        with self.assertNumQueries(56):
            sync_entities()
    def test_sync_all_optimal_queries(self):
        """
        Tests optimal queries of syncing all entities.
        """
        # Create five test accounts
        accounts = [Account.objects.create() for i in range(5)]
        # Create two teams to assign to some of the accounts
        teams = [Team.objects.create() for i in range(2)]
        accounts[0].team = teams[0]
        accounts[0].save()
        accounts[1].team = teams[0]
        accounts[1].save()
        accounts[2].team = teams[1]
        accounts[2].save()
        accounts[3].team = teams[1]
        accounts[3].save()

        # Use an entity registry that only has accounts and teams. This ensures that other registered
        # entity models dont pollute the test case
        new_registry = EntityRegistry()
        new_registry.register_entity(
            Account.objects.select_related('team', 'team2', 'team_group',
                                           'competitor'), AccountConfig)
        new_registry.register_entity(Team.objects.select_related('team_group'),
                                     TeamConfig)

        with patch('entity.sync.entity_registry') as mock_entity_registry:
            mock_entity_registry.entity_registry = new_registry.entity_registry
            ContentType.objects.clear_cache()
            with self.assertNumQueries(20):
                sync_entities()

        self.assertEquals(
            Entity.objects.filter(entity_type=ContentType.objects.
                                  get_for_model(Account)).count(), 5)
        self.assertEquals(
            Entity.objects.filter(
                entity_type=ContentType.objects.get_for_model(Team)).count(),
            2)
        self.assertEquals(Entity.objects.all().count(), 7)

        # There should be four entity relationships since four accounts have teams
        self.assertEquals(EntityRelationship.objects.all().count(), 4)
Beispiel #22
0
    def test_sync_all(self, mock_model_activations_changed):
        """
        Tests that when we sync all we fire the correct signals
        """

        # Create five test accounts
        turn_off_syncing()
        initial_accounts = []
        for i in range(5):
            initial_accounts.append(Account.objects.create())
        turn_on_syncing()

        # Test that the management command syncs all five entities
        self.assertEquals(Entity.objects.all().count(), 0)
        sync_entities()
        self.assertEquals(Entity.objects.all().count(), 5)
        initial_entity_ids = list(Entity.objects.all().values_list('id', flat=True))
        mock_model_activations_changed.send.assert_called_once_with(
            sender=Entity,
            instance_ids=sorted(initial_entity_ids),
            is_active=True
        )

        # Create five new test accounts, and deactivate our initial accounts
        mock_model_activations_changed.reset_mock()
        turn_off_syncing()
        new_accounts = []
        for i in range(5):
            new_accounts.append(Account.objects.create())
        for account in initial_accounts:
            account.delete()
        turn_on_syncing()

        # Sync entities
        sync_entities()

        # Assert that the correct signals were called
        self.assertEqual(
            mock_model_activations_changed.send.mock_calls,
            [
                call(
                    sender=Entity,
                    instance_ids=sorted(list(Entity.objects.filter(
                        entity_id__in=[account.id for account in new_accounts]
                    ).values_list('id', flat=True))),
                    is_active=True
                ),
                call(
                    sender=Entity,
                    instance_ids=sorted(initial_entity_ids),
                    is_active=False
                )
            ]
        )

        # Test syncing all when nothing should have changed
        mock_model_activations_changed.reset_mock()
        sync_entities()
        self.assertFalse(mock_model_activations_changed.send.called)
    def test_sync_all_account_no_teams(self):
        """
        Tests syncing all accounts with no super entities.
        """
        turn_off_syncing()
        # Create five test accounts
        accounts = [Account.objects.create() for i in range(5)]
        turn_on_syncing()

        # Sync all of the entities and verify that five Entity models were created for the Account model
        self.assertEquals(Entity.objects.all().count(), 0)
        sync_entities()
        self.assertEquals(Entity.objects.all().count(), 5)

        # Delete an account. When all entities are synced again,
        # there should only be four accounts
        turn_off_syncing()
        accounts[0].delete()
        turn_on_syncing()

        self.assertEquals(Entity.objects.all().count(), 5)
        sync_entities()
        self.assertEquals(Entity.objects.all().count(), 4)
Beispiel #24
0
    def test_sync_all(self, mock_model_activations_changed):
        """
        Tests that when we sync all we fire the correct signals
        """

        # Create five test accounts
        turn_off_syncing()
        initial_accounts = []
        for i in range(5):
            initial_accounts.append(Account.objects.create())
        turn_on_syncing()

        # Test that the management command syncs all five entities
        self.assertEquals(Entity.objects.all().count(), 0)
        sync_entities()
        self.assertEquals(Entity.objects.all().count(), 5)
        initial_entity_ids = list(Entity.objects.all().values_list('id',
                                                                   flat=True))
        mock_model_activations_changed.send.assert_called_once_with(
            sender=Entity,
            instance_ids=sorted(initial_entity_ids),
            is_active=True)

        # Create five new test accounts, and deactivate our initial accounts
        mock_model_activations_changed.reset_mock()
        turn_off_syncing()
        new_accounts = []
        for i in range(5):
            new_accounts.append(Account.objects.create())
        for account in initial_accounts:
            account.delete()
        turn_on_syncing()

        # Sync entities
        sync_entities()

        # Assert that the correct signals were called
        self.assertEqual(mock_model_activations_changed.send.mock_calls, [
            call(sender=Entity,
                 instance_ids=sorted(
                     list(
                         Entity.objects.filter(entity_id__in=[
                             account.id for account in new_accounts
                         ]).values_list('id', flat=True))),
                 is_active=True),
            call(sender=Entity,
                 instance_ids=sorted(initial_entity_ids),
                 is_active=False)
        ])

        # Test syncing all when nothing should have changed
        mock_model_activations_changed.reset_mock()
        sync_entities()
        self.assertFalse(mock_model_activations_changed.send.called)
Beispiel #25
0
def sync_ambition_entity():
    sync_entities()
Beispiel #26
0
 def run(self, *args, **kwargs):
     # Check if there are selected model objs to update
     if 'model_obj_class' and 'model_obj_ids' in kwargs:
         sync_entities(*kwargs['model_obj_class'].objects.filter(id__in=kwargs['model_obj_ids']))
     else:
         sync_entities()
Beispiel #27
0
 def run(self, *args, **kwargs):
     sync_entities()
 def handle(self, *args, **options):
     """
     Runs sync entities
     """
     sync_entities()
Beispiel #29
0
 def handle(self, *args, **options):
     """
     Runs sync entities
     """
     sync_entities()
Beispiel #30
0
    def test_get_all_entities(self):
        turn_off_syncing()

        account_type = ContentType.objects.get_for_model(Account)
        team_type = ContentType.objects.get_for_model(Team)

        # Set up teams
        teams = Team.objects.bulk_create([Team() for i in range(0, 3)])

        # Set up accounts
        Account.objects.bulk_create(
            [Account(team=teams[i % 3]) for i in range(0, 20)])

        # Turn on syncing and do a sync
        turn_on_syncing()

        sync_entities()

        account_entities = list(
            Entity.all_objects.filter(
                entity_type=account_type).order_by('entity_id'))
        account_kind = account_entities[0].entity_kind

        team_entities = list(
            Entity.all_objects.filter(
                entity_type=team_type).order_by('entity_id'))
        team_kind = team_entities[0].entity_kind

        # Create groups
        EntityGroup.objects.bulk_create([EntityGroup() for i in range(0, 6)])

        # Refresh for django 1.9 because bulk create does not return ids
        entity_groups = list(EntityGroup.objects.order_by('id'))

        # Set up individual entity groups
        entity_groups[0].bulk_add_entities([
            [account_entities[0], None],
            [account_entities[1], None],
            [account_entities[2], None],
            [account_entities[3], None],
        ])
        entity_groups[1].bulk_add_entities([
            [account_entities[2], None],
            [account_entities[3], None],
            [account_entities[4], None],
            [account_entities[5], None],
        ])

        # Set up sub entity kind of super entity groups
        entity_groups[2].bulk_add_entities([
            [team_entities[0], account_kind],
            [team_entities[1], account_kind],
        ])

        entity_groups[3].bulk_add_entities([
            [team_entities[0], account_kind],
        ])

        # Set up sub entity kind groups
        # This group has two copies of the same set of all accounts as well as all teams
        entity_groups[4].bulk_add_entities([
            [None, account_kind],
            [None, account_kind],
            [None, team_kind],
        ])

        # This group has the same copy of all accounts
        entity_groups[5].bulk_add_entities([
            [None, account_kind],
        ])

        with self.assertNumQueries(3):
            membership_cache = EntityGroup.objects.get_membership_cache()
            entities_by_kind = get_entities_by_kind(
                membership_cache=membership_cache)

            for entity_group in entity_groups:
                entity_group.get_all_entities(membership_cache,
                                              entities_by_kind)

        with self.assertNumQueries(3):
            get_entities_by_kind()

        # Make sure to hit the no group cache case
        self.assertEqual(
            entity_groups[0].get_all_entities(membership_cache={1000: []}),
            set())
    def test_get_all_entities(self):
        turn_off_syncing()

        account_type = ContentType.objects.get_for_model(Account)
        team_type = ContentType.objects.get_for_model(Team)

        # Set up teams
        teams = Team.objects.bulk_create([
            Team()
            for i in range(0, 3)
        ])

        # Set up accounts
        Account.objects.bulk_create([
            Account(team=teams[i % 3])
            for i in range(0, 20)
        ])

        # Turn on syncing and do a sync
        turn_on_syncing()

        sync_entities()

        account_entities = list(Entity.all_objects.filter(entity_type=account_type).order_by('entity_id'))
        account_kind = account_entities[0].entity_kind

        team_entities = list(Entity.all_objects.filter(entity_type=team_type).order_by('entity_id'))
        team_kind = team_entities[0].entity_kind

        # Create groups
        EntityGroup.objects.bulk_create([
            EntityGroup()
            for i in range(0, 6)
        ])

        # Refresh for django 1.9 because bulk create does not return ids
        entity_groups = list(EntityGroup.objects.order_by('id'))

        # Set up individual entity groups
        entity_groups[0].bulk_add_entities([
            [account_entities[0], None],
            [account_entities[1], None],
            [account_entities[2], None],
            [account_entities[3], None],
        ])
        entity_groups[1].bulk_add_entities([
            [account_entities[2], None],
            [account_entities[3], None],
            [account_entities[4], None],
            [account_entities[5], None],
        ])

        # Set up sub entity kind of super entity groups
        entity_groups[2].bulk_add_entities([
            [team_entities[0], account_kind],
            [team_entities[1], account_kind],
        ])

        entity_groups[3].bulk_add_entities([
            [team_entities[0], account_kind],
        ])

        # Set up sub entity kind groups
        # This group has two copies of the same set of all accounts as well as all teams
        entity_groups[4].bulk_add_entities([
            [None, account_kind],
            [None, account_kind],
            [None, team_kind],
        ])

        # This group has the same copy of all accounts
        entity_groups[5].bulk_add_entities([
            [None, account_kind],
        ])

        with self.assertNumQueries(3):
            membership_cache = EntityGroup.objects.get_membership_cache()
            entities_by_kind = get_entities_by_kind(membership_cache=membership_cache)

            for entity_group in entity_groups:
                entity_group.get_all_entities(membership_cache, entities_by_kind)

        with self.assertNumQueries(3):
            get_entities_by_kind()

        # Make sure to hit the no group cache case
        self.assertEqual(entity_groups[0].get_all_entities(membership_cache={1000: []}), set())