Exemple #1
0
    def setUp(self):
        events.unsub_all()

        parser = AstromParser()
        directory_manager = LocalDirectoryWorkingContext(
            self._get_working_dir())
        self.context = directory_manager
        progress_manager = LocalProgressManager(directory_manager)
        workunit_provider = WorkUnitProvider(
            tasks.get_suffix(self._get_task()), directory_manager,
            progress_manager,
            self._get_workunit_builder(parser, progress_manager))

        self.workunit_provider = workunit_provider
        self.progress_manager = progress_manager

        self.singlet_download_manager = Mock(spec=AsynchronousDownloadManager)
        self.triplet_download_manager = Mock(spec=AsynchronousDownloadManager)
        self.image_manager = ImageManager(self.singlet_download_manager,
                                          self.triplet_download_manager)

        self.model = ValidationModel(self.workunit_provider,
                                     self.image_manager, None)

        self.custom_setup()

        self.model.start_work()
Exemple #2
0
    def setUp(self):
        super(RealsModelPersistenceTest, self).setUp()

        concurrent_directory_manager = LocalDirectoryWorkingContext(
            self._get_working_dir())
        self.concurrent_progress_manager = LocalProgressManager(
            concurrent_directory_manager)
Exemple #3
0
 def setUp(self):
     self.main_user_id = "main_user"
     self.working_directory = self.get_abs_path(WD_NO_LOG)
     directory_manager = LocalDirectoryWorkingContext(
         self.working_directory)
     self.progress_manager = LocalProgressManager(directory_manager,
                                                  userid=self.main_user_id)
Exemple #4
0
    def setUp(self):
        WxWidgetTestCase.setUp(self)

        parser = AstromParser()
        context = LocalDirectoryWorkingContext(
            self.get_abs_path("data/controller_testdir"))
        progress_manager = LocalProgressManager(context)
        workunit_provider = WorkUnitProvider(tasks.get_suffix(tasks.REALS_TASK),
                                             context, progress_manager,
                                             RealsWorkUnitBuilder(
                                                 parser,
                                                 context,
                                                 context,
                                                 progress_manager))

        image_manager = Mock(spec=ImageManager)

        self.model = ValidationModel(workunit_provider, image_manager, None)
        self.model.start_work()

        self.model.get_writer = Mock(return_value=Mock(spec=mpc.MPCWriter))

        # We don't actually have any images loaded, so mock this out
        source_cutout = Mock(spec=SourceCutout)
        source_cutout.pixel_x = 11
        source_cutout.pixel_y = 50
        self.model.get_current_cutout = Mock(return_value=source_cutout)

        x_cen = 10
        y_cen = 50
        mag = 24.0
        self.model.get_current_source_observed_magnitude = Mock(return_value=(x_cen, y_cen, mag))

        self.model.is_current_source_adjusted = Mock(return_value=False)
        self.model.get_current_fits_header = Mock()

        self.name_generator = Mock(spec=ProvisionalNameGenerator)
        self.name_generator.generate_name.return_value = TEST_PROVISIONAL_NAME

        class TestFactory(object):
            def __init__(self, model, name_generator):
                self.model = model
                self.name_generator = name_generator

            def create_controller(self, view):
                return ProcessRealsController(self.model, view,
                                              self.name_generator)

        self.view = ApplicationView(
            TestFactory(self.model, self.name_generator))
        self.controller = self.view.controller
        self.controller.display_current_image = Mock()
Exemple #5
0
 def get_progress_manager(self):
     return LocalProgressManager(self, userid=self.userid)
Exemple #6
0
 def create_concurrent_progress_manager(self, userid="test_user"):
     directory_manager = LocalDirectoryWorkingContext(
         self.working_directory)
     return LocalProgressManager(directory_manager, userid=userid)
Exemple #7
0
 def setUp(self):
     self.working_directory = self.get_abs_path(WD_HAS_PROGRESS)
     directory_manager = LocalDirectoryWorkingContext(
         self.working_directory)
     self.progress_manager = LocalProgressManager(directory_manager)