mock.sentinel.ignored

Here are the examples of the python api mock.sentinel.ignored taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

11 Examples 7

Example 1

Project: edx-analytics-pipeline Source File: test_data_obfuscation.py
    def test_data_directory(self):
        """Test to check whether the data_directory for a course is being set up correctly."""
        coursename = 'edx_demo_course'
        self.create_paths(coursename, dates=['2015-11-25', '2015-11-28', '2015-12-06'])
        task = obfuscate.ObfuscatedCourseDumpTask(
            course=coursename, dump_root=self.dump_root, output_root=self.output_root,
            auth_user_path=sentinel.ignored, auth_userprofile_path=sentinel.ignored,
        )
        self.assertEquals(task.data_directory, url_path_join(self.dump_root, coursename, 'state', '2015-12-06'))

Example 2

Project: edx-analytics-pipeline Source File: test_user_registrations.py
Function: create_task
    def create_task(self, interval):
        """
        Args:
            interval (luigi.date_interval.DateInterval): The interval of dates to gather data for.

        Returns:
            A dummy task that uses the provided `interval` as it's date_interval.
        """
        return UserRegistrationsPerDay(
            credentials=sentinel.ignored,
            destination=sentinel.ignored,
            date_interval=interval
        )

Example 3

Project: edx-analytics-pipeline Source File: test_data_obfuscation.py
Function: run_task
    def run_task(self, task_cls, source):
        """Runs the task with fake targets."""

        task = task_cls(
            course=sentinel.ignored,
            output_directory=sentinel.ignored,
            data_directory=sentinel.ignored,
            auth_user_path=sentinel.ignored,
            auth_userprofile_path=sentinel.ignored,
        )

        fake_input = {'data': [FakeTarget(value=source)]}
        task.input = MagicMock(return_value=fake_input)

        output_target = FakeTarget()
        task.output = MagicMock(return_value=output_target)
        task.user_info_requirements = get_mock_user_info_requirements()
        reset_user_info_for_testing()
        task.run()
        return output_target.buffer.read()

Example 4

Project: edx-analytics-pipeline Source File: test_data_obfuscation.py
Function: run_task
    def run_task(self):
        """Runs the task with fake targets."""

        output_archive_root = tempfile.mkdtemp()
        self.addCleanup(shutil.rmtree, output_archive_root)

        with tempfile.NamedTemporaryFile() as tmp_input_archive:
            with tarfile.open(mode='w:gz', fileobj=tmp_input_archive) as input_archive_file:
                input_archive_file.add(self.archive_root, arcname='')
            tmp_input_archive.seek(0)

            task = obfuscate.CourseContentTask(
                course=sentinel.ignored,
                output_directory=sentinel.ignored,
                data_directory=sentinel.ignored,
                auth_user_path=sentinel.ignored,
                auth_userprofile_path=sentinel.ignored,
            )

            fake_input = {'data': [LocalTarget(path=tmp_input_archive.name)]}
            task.input = MagicMock(return_value=fake_input)

            output_target = FakeTarget()
            task.output = MagicMock(return_value=output_target)
            task.user_info_requirements = get_mock_user_info_requirements()
            reset_user_info_for_testing()
            task.run()

            with tarfile.open(mode='r:gz', fileobj=output_target.buffer) as output_archive_file:
                output_archive_file.extractall(output_archive_root)

        self.output_course_root = os.path.join(output_archive_root, get_filename_safe_course_id(self.COURSE_ID))

Example 5

Project: edx-analytics-pipeline Source File: test_mysql.py
Function: set_up
    def setUp(self):
        self.task = MysqlSelectTask(
            credentials=sentinel.ignored,
            destination=sentinel.ignored
        )

Example 6

Project: edx-analytics-pipeline Source File: test_mysql.py
Function: run_task
    def run_task(self, credentials=None, query=None):
        """
        Emulate execution of a generic MysqlSelectTask.
        """
        if not credentials:
            credentials = '''\
                {
                    "host": "db.example.com",
                    "port": "3306",
                    "username": "exampleuser",
                    "password": "example password"
                }'''

        if not query:
            query = 'SELECT 1'

        # Create a dummy task that simply returns the parameters given
        class TestTask(MysqlSelectTask):
            """A generic MysqlSelectTask that wraps the parameters from the enclosing function"""

            database = "exampledata"

            @property
            def query(self):
                return query

            @property
            def filename(self):
                return None  # pragma: no cover

        task = TestTask(
            credentials=sentinel.ignored,
            destination=sentinel.ignored
        )

        fake_input = {
            'credentials': FakeTarget(value=textwrap.dedent(credentials))
        }
        task.input = MagicMock(return_value=fake_input)

        output_target = FakeTarget()
        task.output = MagicMock(return_value=output_target)

        task.run()

        try:
            parsed = read_csv(output_target.buffer,
                              header=None,
                              sep="\t",
                              na_values=['-'],
                              encoding='utf-8')
        except ValueError:
            parsed = None

        return parsed

Example 7

Project: edx-analytics-pipeline Source File: test_mysql_load.py
Function: create_task
    def create_task(self, credentials=None, source=None, insert_chunk_size=100, overwrite=False, cls=InsertToMysqlDummyTable):
        """
         Emulate execution of a generic MysqlTask.
        """
        # Make sure to flush the instance cache so we create
        # a new task object.
        luigi.task.Register.clear_instance_cache()
        task = cls(
            credentials=sentinel.ignored,
            insert_chunk_size=insert_chunk_size,
            overwrite=overwrite
        )

        if not credentials:
            credentials = '''\
                {
                    "host": "db.example.com",
                    "port": "3306",
                    "username": "exampleuser",
                    "password": "example password"
                }'''

        if not source:
            source = self._get_source_string(1)

        fake_input = {
            'credentials': FakeTarget(value=textwrap.dedent(credentials)),
            'insert_source': FakeTarget(value=textwrap.dedent(source))
        }

        task.input = MagicMock(return_value=fake_input)
        return task

Example 8

Project: edx-analytics-pipeline Source File: test_sqoop.py
Function: create_task
    def create_task(self, num_mappers=None, where=None, verbose=False,
                    columns=None, null_string=None, fields_terminated_by=None, delimiter_replacement=None,
                    overwrite=False, direct=True, mysql_delimiters=True):
        """Create a SqoopImportFromMysql with specified options."""
        task = SqoopImportFromMysql(
            credentials=sentinel.ignored,
            database='exampledata',
            destination="/fake/destination",
            table_name="example_table",
            num_mappers=num_mappers,
            where=where,
            verbose=verbose,
            columns=columns if columns is not None else [],
            null_string=null_string,
            fields_terminated_by=fields_terminated_by,
            delimiter_replacement=delimiter_replacement,
            overwrite=overwrite,
            direct=direct,
            mysql_delimiters=mysql_delimiters,
        )
        return task

Example 9

Project: edx-analytics-pipeline Source File: test_vertica_load.py
Function: create_task
    def create_task(self, credentials=None, source=None, overwrite=False, cls=CopyToVerticaDummyTable):
        """
         Emulate execution of a generic VerticaCopyTask.
        """
        # Make sure to flush the instance cache so we create
        # a new task object.
        luigi.task.Register.clear_instance_cache()
        task = cls(
            credentials=sentinel.ignored,
            overwrite=overwrite
        )

        if not credentials:
            credentials = '''\
                {
                    "host": "db.example.com",
                    "port": 5433,
                    "user": "exampleuser",
                    "password": "example password"
                }'''

        if not source:
            source = self._get_source_string(1)

        fake_input = {
            'credentials': FakeTarget(value=textwrap.dedent(credentials)),
            'insert_source': FakeTarget(value=textwrap.dedent(source))
        }

        fake_output = MagicMock(return_value=self.mock_vertica_connector)
        self.mock_vertica_connector.marker_schema = "name_of_marker_schema"
        self.mock_vertica_connector.marker_table = "name_of_marker_table"

        task.input = MagicMock(return_value=fake_input)
        task.output = fake_output
        return task

Example 10

Project: edx-analytics-pipeline Source File: test_video.py
Function: set_up
    def setUp(self):
        self.task = VideoUsageTask(interval=sentinel.ignored, output_root=sentinel.ignored)
        self.usage_map = self.generate_usage_map(20)

Example 11

Project: edx-analytics-pipeline Source File: test_video.py
Function: set_up
    def setUp(self):
        self.task = VideoUsageTask(interval=sentinel.ignored, output_root=sentinel.ignored)