class TestManagerModelWithNoJob:

    def setup(self):
        self.model = ManagerModel()

    def teardown(self):
        self.model = None

    def test_init(self):
        ec = EventCatcher(self.model.init_event)
        self.model.init()
        assert_catch_event(ec)

    def test_get_newjob(self):
        assert_catch_exc(JobNotFoundError, self.model.get_newjob)

    def test_get_job_dict(self):
        job_dict = self.model.get_job_dict()
        assert_equal(0, len(job_dict))

    def test_set_selected_jobid_list(self):
        assert_catch_exc(JobNotFoundError,
                         self.model.set_selected_jobid_list, [])
        assert_catch_exc(JobNotFoundError,
                         self.model.set_selected_jobid_list, [1])

    def test_append_job(self):
        from job_model     import JobModel
        from job_view      import JobView
        from job_presenter import JobPresenter
        job = JobMock(5)
        self.model.append_job(job)
        m, v, p = self.model.get_newjob()
        assert isinstance(m, JobModel     ) 
        assert isinstance(v, JobView      ) 
        assert isinstance(p, JobPresenter ) 

    def test_delete_job(self):
        """Test the method: delete_job."""
        assert_catch_exc(JobNotFoundError, self.model.delete_job, 'job')

    def test_update_per_time(self):
        """Test the method: update_per_time."""
        pass
        info_list = self.binder.get_info(listener_name)
        for info in info_list:
            obj = info['object_name']
            evt = info['event_name']
            cls = info['class_name']
            mes = 'Recieved {0} of {1}:{2} at {3}'
            Log( mes.format(evt, obj, cls, listener_name) )

if __name__ == '__main__':
    import wx
    app = wx.App(redirect=False)
    frame = wx.Frame(None, -1, 'Job ListCtrl')

    from manager_model import ManagerModel
    from manager_view  import ManagerView
    model  = ManagerModel()
    view   = ManagerView(frame)
    presen = ManagerPresenter(model, view)

    # create Job
    from tests.jobmock import JobMock
    job = JobMock(1)
    ## set properties
    #init_prop_dict = dict(
        #id            = 5           , 
        #expected_time = '3:00'      , 
        #start_time    = '15:00'     , 
        #elasped_time  = '1:00'      , 
        #finish_time   = ''          , 
        #location      = 'hpcs'      , 
        #jms           = 'LSF'       , 
 def setup(self):
     self.model = ManagerModel()
     job = JobMock(3)
     self.model.append_job(job)
class TestManagerModelWithOneJob:

    def setup(self):
        self.model = ManagerModel()
        job = JobMock(3)
        self.model.append_job(job)

    def teardown(self):
        self.model = None

    def test_init(self):
        # test init
        ec = EventCatcher(self.model.init_event)
        self.model.init()
        assert_catch_event(ec)

        job_dict = self.model.get_job_dict()
        assert_equal(1, len(job_dict))

    def test_get_newjob(self):
        assert_not_catch_exc(JobNotFoundError, self.model.get_newjob)

        m, v, p = self.model.get_newjob()
        assert isinstance(m, JobModel     ) 
        assert isinstance(v, JobView      ) 
        assert isinstance(p, JobPresenter ) 

    def test_get_job_dict(self):
        assert_not_catch_exc(JobNotFoundError, self.model.get_job_dict)
        job_dict = self.model.get_job_dict()
        assert_equal(1, len(job_dict))

        for id, job in job_dict.items():
            id = id
            job = job

        newjob = self.model.get_newjob()
        assert_equal(job_dict[id], newjob)

    def test_set_selected_jobid_list(self):
        assert_catch_exc(JobNotFoundError,
                         self.model.set_selected_jobid_list, [1,2,3,4,5])
        assert_catch_exc(JobNotFoundError,
                         self.model.set_selected_jobid_list, [5])
        assert_not_catch_exc(JobNotFoundError,
                         self.model.set_selected_jobid_list, [3])

    def test_append_job(self):
        old_job = self.model.get_newjob()
        job = JobMock(8)
        self.model.append_job(job)
        new_job = self.model.get_newjob()

        assert_not_equal(old_job, new_job)

        job_dict = self.model.get_job_dict()
        assert_equal(2, len(job_dict) )

    def test_delete_job(self):
        """Test the method: delete_job."""
        ec = EventCatcher(self.model.update_event)
        assert_catch_exc(JobNotFoundError, self.model.delete_job, 9)

        self.model.delete_job( 3 )
        assert_catch_event(ec)
        assert_equal( 0, len(self.model.get_job_dict()) )
 def setup(self):
     self.model = ManagerModel()
 def setup(self):
     self.model = ManagerModel()
     job1 = JobMock(3)
     job2 = JobMock(25)
     self.model.append_job(job1)
     self.model.append_job(job2)
class TestManagerModelWithMoreThanTwoJob:

    def setup(self):
        self.model = ManagerModel()
        job1 = JobMock(3)
        job2 = JobMock(25)
        self.model.append_job(job1)
        self.model.append_job(job2)

    def teardown(self):
        self.model = None

    def test_init(self):
        # test init
        ec = EventCatcher(self.model.init_event)
        self.model.init()
        assert_catch_event(ec)

        job_dict = self.model.get_job_dict()
        assert_equal(2, len(job_dict))

    def test_get_newjob(self):
        assert_not_catch_exc(JobNotFoundError, self.model.get_newjob)

        m, v, p = self.model.get_newjob()
        assert_equal(m.id, 25)

    def test_get_job_dict(self):
        job_dict = self.model.get_job_dict()
        assert_equal(2, len(job_dict))

        job1 = job_dict[3]
        job2 = job_dict[25]
        assert_not_equal(job1, job2)

    def test_set_selected_jobid_list(self):
        assert_catch_exc(
            JobNotFoundError, self.model.set_selected_jobid_list, [1,2,3,4,5])
        assert_not_catch_exc(
            JobNotFoundError, self.model.set_selected_jobid_list, [3])
        assert_not_catch_exc(
            JobNotFoundError, self.model.set_selected_jobid_list, [25])
        assert_not_catch_exc(
            JobNotFoundError, self.model.set_selected_jobid_list, [3,25])

    def test_append_job(self):
        snd_job = self.model.get_newjob()

        job = JobMock(8)
        self.model.append_job(job)
        new_job = self.model.get_newjob()

        assert_equal(snd_job, new_job)

        job_dict = self.model.get_job_dict()
        print job_dict.keys()
        assert_equal(3, len(job_dict) )
        assert_equal( set([3,8,25]), set(job_dict.keys()) )

    def test_delete_job(self):
        """Test the method: delete_job."""
        ec = EventCatcher(self.model.update_event)
        assert_catch_exc(JobNotFoundError, self.model.delete_job, 12)

        self.model.delete_job( 3 )
        assert_catch_event(ec)
        assert_equal( 1, len(self.model.get_job_dict()) )

        self.model.delete_job( 25 )
        assert_catch_event(ec)
        assert_equal( 0, len(self.model.get_job_dict()) )