def test_address_partial(self):
     for x in range(50):
         initial_data, validate_against = self.gen_addres_test_set()
         rand_address = SalesManagoClientData(**initial_data)
         self.assertEqual(rand_address.address, validate_against)
 def test_tags_direct_creation(self):
     _rich_client_data = self._rich_client_data(fields=['email','owner'])
     _rich_client_data['tags'] = gen_list_of_strings(10)
     cd = SalesManagoClientData(**_rich_client_data)
     self.assertEqual(cd.tags, _rich_client_data['tags'].copy())
    def test_requestDict_with_partial_data_for_insert(self):
        TEST_ARGS = [
            'birthday', 'province', 'forceOptOut', 'forceOptIn',
            'forcePhoneOptOut', 'forcePhoneOptIn', 'useApiDoubleOptIn',
            'newEmail', 'externalId', 'lang', 'tags', 'removeTags',
            'properties', 'contact'
        ]

        for x in range(50):
            initial_data = self._rich_client_data(no_contact=True,
                                                  no_address=True)
            validate_against = {
                'contact': {
                    'email': self.CLIENT_MAIL
                },
                'owner': self.OWNER_MAIL
            }

            num_args = random.randint(1, len(TEST_ARGS))
            RANDOM_TEST_ARGS = random.sample(TEST_ARGS, num_args)

            #required
            RANDOM_TEST_ARGS.append('owner')

            if 'contact' in RANDOM_TEST_ARGS:
                contact_initial_data, contact_validate_against = self.get_contact_test_data_set(
                    'insert', only_contact=True)
                initial_data.update(contact_initial_data)
                validate_against['contact'] = contact_validate_against

            #all w/o iterables
            for arg in TEST_ARGS[:-4]:

                if arg not in RANDOM_TEST_ARGS:
                    del initial_data[arg]
                else:
                    validate_against[arg] = initial_data[arg]

                if 'birthday' in validate_against:
                    validate_against['birthday'] = initial_data[
                        'birthday'].strftime('%Y%m%d')

            rand_address = SalesManagoClientData(**initial_data)

            if 'tags' in RANDOM_TEST_ARGS:
                validate_against['tags'] = []
                for tag in tests_utils.gen_list_of_strings(
                        random.randint(1, 20)):
                    rand_address.add_tag(tag)
                    validate_against['tags'].append(tag)

            if 'removeTags' in RANDOM_TEST_ARGS:
                validate_against['removeTags'] = []
                for tag in tests_utils.gen_list_of_strings(
                        random.randint(1, 20)):
                    rand_address.add_removeTags(tag)
                    validate_against['removeTags'].append(tag)

            if 'properties' in RANDOM_TEST_ARGS:
                validate_against['properties'] = {}
                for key, value in tests_utils.gen_dict(random.randint(
                        1, 20)).items():
                    rand_address.add_property(key, value)
                    validate_against['properties'][key] = value

            self.assertEqual(rand_address.requestDict(request_format='insert'),
                             validate_against)
 def test_create_minimal_client(self):
     clientClass = SalesManagoClientData(email=self.CLIENT_MAIL, owner=self.OWNER_MAIL)
     self.assertEqual(clientClass.email, self.CLIENT_MAIL)
     self.assertEqual(clientClass.owner, self.OWNER_MAIL)
 def test_state_values_on_change(self):
     with self.assertRaises(ValueError):
         _rich_client_data = self._rich_client_data()
         cd = SalesManagoClientData(**_rich_client_data)
         cd.state = 'ASDASDA'
 def test_owner_not_provided(self):
     with self.assertRaises(ValueError):
         SalesManagoClientData(email=self.VALID_MAIL)
 def test_state_values_on_creation(self):
     with self.assertRaises(ValueError):
         _rich_client_data = self._rich_client_data()
         _rich_client_data['state'] = 'ASDASDA'
         cd = SalesManagoClientData(**_rich_client_data)
    def test_create_rich_client_with_invalid_birthday_type(self):
        _rich_client_data = self._rich_client_data()
        _rich_client_data['birthday'] = '20200101'

        with self.assertRaises(TypeError):
            SalesManagoClientData(**_rich_client_data)
    def test_change_birthday_to_invalid_type(self):
        _rich_client_data = self._rich_client_data()

        with self.assertRaises(TypeError):
            cd = SalesManagoClientData(**_rich_client_data)
            cd.birthday = '20200101'
 def test_owner_validated_on_change(self):
     with self.assertRaises(ValueError):
         for invalid_email in self.INVALID_MAILS:
             _rich_client_data = self._rich_client_data()
             cd = SalesManagoClientData(**_rich_client_data)
             cd.owner = invalid_email
    def test_create_rich_client_creation(self):
        rcd = self._rich_client_data()
        rich_client = SalesManagoClientData(**rcd)

        for key, value in rcd.items():
            self.assertEqual(getattr(rich_client, key), value)
 def test_owner_validated_on_create(self):
     with self.assertRaises(ValueError):
         for invalid_email in self.INVALID_MAILS:
             SalesManagoClientData(email=self.VALID_MAIL, owner=invalid_email)
 def test_properties_direct_creation_invalid_type(self):
     _rich_client_data = self._rich_client_data(fields=['email','owner'])
     _rich_client_data['properties'] = gen_list_of_strings(10)
     with self.assertRaises(TypeError):
         cd = SalesManagoClientData(**_rich_client_data)
 def test_properties_direct_creation(self):
     _rich_client_data = self._rich_client_data(fields=['email','owner'])
     _rich_client_data['properties'] = gen_dict(10)
     cd = SalesManagoClientData(**_rich_client_data)
     self.assertEqual(cd.properties, _rich_client_data['properties'].copy())
 def test_contact_partial_data_insert(self):
     for x in range(50):
         initial_data, validate_against = self.get_contact_test_data_set(
             'insert')
         rand_address = SalesManagoClientData(**initial_data)
         self.assertEqual(rand_address.contact('insert'), validate_against)
 def test_newEmail_validated_on_create(self):
     _rich_client_data = self._rich_client_data()
     with self.assertRaises(ValueError):
         for invalid_email in self.INVALID_MAILS:
             _rich_client_data['newEmail'] = invalid_email
             SalesManagoClientData(**_rich_client_data)
Exemple #17
0
    def setUp(self) -> None:
        self.clientClass = SalesManagoClientData(email=self.CLIENT_MAIL,
                                                 owner=self.OWNER_MAIL)

        self.rcd = self._rich_client_data()
        self.richClientClass = SalesManagoClientData(**self.rcd)
 def test_removeTags_direct_creation_invalid_type(self):
     _rich_client_data = self._rich_client_data(fields=['email','owner'])
     _rich_client_data['removeTags'] = gen_dict(10)
     with self.assertRaises(TypeError):
         cd = SalesManagoClientData(**_rich_client_data)