class LogWindowController(object):
    def __init__(self, runner, logWindow):
        self.runner = runner
        self.logWindow = logWindow
        self.signal = StringSignal()
        self.signal.get().connect(self.logWindow.appendMessage)
        self.outputEmitter = None
        self.errorEmitter = None

    def runAsync(self):
        if not self.runner.isRunning():
            self.runner.executeAsync()

        self.outputEmitter = GeneratorEmitter(self.runner.outputStream(), self.signal.get())
        self.errorEmitter = GeneratorEmitter(self.runner.errorStream(), self.signal.get())
        self.outputEmitter.start()
        self.errorEmitter.start()

    def run(self):
        if not self.runner.isRunning():
            self.runner.executeAsync()

        self.outputEmitter = GeneratorEmitter(self.runner.outputStream(), self.signal.get())
        self.errorEmitter = GeneratorEmitter(self.runner.errorStream(), self.signal.get())
        self.outputEmitter.run()
        self.errorEmitter.run()

    def join(self):
        output, error = self.runner.join()
        if output:
            self.signal.get().emit(output)
        if error:
            self.signal.get().emit(error)
        self.outputEmitter.wait()
        self.errorEmitter.wait()
    def test_canEmitStringSignals(self):
        self.received = False
        sentMessage = 'Foobar'

        def receive(s):
            self.assertIsInstance(s, QString)
            self.assertEqual(sentMessage, s)
            self.received = True

        signal = StringSignal()
        signal.get().connect(receive)
        signal.get().emit(sentMessage)
        self.assertTrue(self.received)
 def __init__(self, runner, logWindow):
     self.runner = runner
     self.logWindow = logWindow
     self.signal = StringSignal()
     self.signal.get().connect(self.logWindow.appendMessage)
     self.outputEmitter = None
     self.errorEmitter = None
    def test_canEmitMessageFromSeparateThread(self):
        signal = StringSignal()
        window = LogWindow(None)
        signal.get().connect(window.appendMessage)

        class EmitterThread(QtCore.QThread):
            def __init__(self, signal, args):
                QtCore.QThread.__init__(self)
                self.signal = signal
                self.args = args

            def run(self):
                self.signal.emit(*self.args)

        thread = EmitterThread(signal.get(), ['Foobar'])
        thread.run()
        thread.wait()

        self.assertEqual('Foobar', window.toPlainText())
    def test_differentInstancesAreIndependent(self):
        messages1 = []
        messages2 = []

        def receive1(s):
            messages1.append(str(s))

        def receive2(s):
            messages2.append(str(s))

        signal1 = StringSignal()
        signal2 = StringSignal()
        signal1.get().connect(receive1)
        signal2.get().connect(receive2)

        signal1.get().emit('')
        self.assertEqual(1, len(messages1))
        self.assertEqual(0, len(messages2))
        signal2.get().emit('')
        self.assertEqual(1, len(messages1))
        self.assertEqual(1, len(messages2))
 def test_canConnectSignalToAppendMessageSlot(self):
     signal = StringSignal()
     window = LogWindow(None)
     signal.get().connect(window.appendMessage)
     signal.get().emit('Foobar')
     self.assertEqual('Foobar', window.toPlainText())