예제 #1
0
	def test_run (self):
		m = simple_machine()
		step_d, step = simple_step()

		expt = Experiment(step)
		expt.register_machine(m)

		expt.run()
		self.assertEqual(expt.state, State.RUNNING)
		self.assertEqual(m.reset.call_count, 0)

		m.ready.callback(True)
		m.reset.assert_called_once_with()
		self.assertEqual(step.run.call_count, 0)

		m.reset_d.callback(True)
		step.run.assert_called_once_with()

		step_d.callback(None)
예제 #2
0
    def test_run(self):
        m = simple_machine()
        step_d, step = simple_step()

        expt = Experiment(step)
        expt.register_machine(m)

        expt.run()
        self.assertEqual(expt.state, State.RUNNING)
        self.assertEqual(m.reset.call_count, 0)

        m.ready.callback(True)
        m.reset.assert_called_once_with()
        self.assertEqual(step.run.call_count, 0)

        m.reset_d.callback(True)
        step.run.assert_called_once_with()

        step_d.callback(None)
예제 #3
0
    def test_double_run(self):
        step_d, step = simple_step()

        # Initialisation
        expt = Experiment(step)

        # Run twice gives an error
        expt_d = expt.run()
        self.assertRaises(Exception, expt.run)

        step_d.callback(None)
예제 #4
0
	def test_double_run (self):
		step_d, step = simple_step()

		# Initialisation
		expt = Experiment(step)

		# Run twice gives an error
		expt_d = expt.run()
		self.assertRaises(Exception, expt.run)

		step_d.callback(None)
예제 #5
0
    def test_normal_run(self):
        step_d, step = simple_step()

        # Initialisation
        expt = Experiment(step)
        self.assertEqual(expt.state, State.READY)

        # Run
        expt_d = expt.run()
        self.assertEqual(expt.state, State.RUNNING)
        step.run.assert_called_once_with()

        result = "my_result"
        step_d.callback(result)

        self.assertEqual(expt.state, State.COMPLETE)
        self.assertEqual(expt_d.called, True)
예제 #6
0
	def test_normal_run (self):
		step_d, step = simple_step()

		# Initialisation
		expt = Experiment(step)
		self.assertEqual(expt.state, State.READY)

		# Run
		expt_d = expt.run()
		self.assertEqual(expt.state, State.RUNNING)
		step.run.assert_called_once_with()

		result = "my_result"
		step_d.callback(result)

		self.assertEqual(expt.state, State.COMPLETE)
		self.assertEqual(expt_d.called, True)
예제 #7
0
    def test_stop(self):
        from octopus.sequence import Stopped

        # Initialisation
        step_d, step = simple_step()
        expt = Experiment(step)
        expt_d = expt.run()

        # Stop
        self.assertEqual(expt.state, State.RUNNING)

        stop_d = expt.stop()
        step.abort.assert_called_once_with()
        self.assertEqual(expt.state, State.RUNNING)

        step_d.errback(Stopped())
        self.assertEqual(expt.state, State.ERROR)
        self.assertFailure(expt_d, Stopped)
        self.assertEqual(len(step.log.handlers), 0)
예제 #8
0
    def test_pause_resume(self):
        # Initialisation
        step_d, step = simple_step()
        expt = Experiment(step)
        expt_d = expt.run()

        # Pause
        pause_d = expt.pause()
        step.pause.assert_called_once_with()
        self.assertEqual(expt.state, State.PAUSED)
        self.assertEqual(pause_d.result, [None])

        # Resume
        resume_d = expt.resume()
        step.resume.assert_called_once_with()
        self.assertEqual(expt.state, State.RUNNING)
        self.assertEqual(resume_d.result, [None])

        step_d.callback(None)
예제 #9
0
	def test_stop (self):
		from octopus.sequence import Stopped

		# Initialisation
		step_d, step = simple_step()
		expt = Experiment(step)
		expt_d = expt.run()

		# Stop
		self.assertEqual(expt.state, State.RUNNING)

		stop_d = expt.stop()
		step.abort.assert_called_once_with()
		self.assertEqual(expt.state, State.RUNNING)

		step_d.errback(Stopped())
		self.assertEqual(expt.state, State.ERROR)
		self.assertFailure(expt_d, Stopped)
		self.assertEqual(len(step.log.handlers), 0)
예제 #10
0
	def test_pause_resume (self):
		# Initialisation
		step_d, step = simple_step()
		expt = Experiment(step)
		expt_d = expt.run()

		# Pause
		pause_d = expt.pause()
		step.pause.assert_called_once_with()
		self.assertEqual(expt.state, State.PAUSED)
		self.assertEqual(pause_d.result, [None])

		# Resume
		resume_d = expt.resume()
		step.resume.assert_called_once_with()
		self.assertEqual(expt.state, State.RUNNING)
		self.assertEqual(resume_d.result, [None])

		step_d.callback(None)